doc/man/task-tutorial.5 doc/man/task.1 doc/man/taskrc.5 doc/misc/grammar.bnf doc/misc/script.txt i18n/strings.de-DE i18n/strings.en-US i18n/strings.es-ES i18n/strings.fr-FR i18n/strings.nl-NL i18n/strings.sv-SE i18n/tips.de-DE i18n/tips.en-US i18n/tips.sv-SE package-config/README package-config/cygwin/CYGWIN-PATCHES/setup.hint package-config/cygwin/CYGWIN-PATCHES/task-1.7.1-1.README package-config/cygwin/task-1.7.1-1.patch package-config/cygwin/usr/share/doc/Cygwin/task-1.7.1-1.README package-config/fedora/task.spec package-config/osx/binary/COPYING.txt package-config/osx/binary/README.txt package-config/osx/task.pmdoc/01task-contents.xml package-config/osx/task.pmdoc/01task.xml package-config/osx/task.pmdoc/index.xml package-config/ubuntu/debian/changelog package-config/ubuntu/debian/compat package-config/ubuntu/debian/control package-config/ubuntu/debian/copyright package-config/ubuntu/debian/docs package-config/ubuntu/debian/rules package-config/ubuntu/debian/watch scripts/bash/task_completion.sh scripts/vim/README scripts/vim/ftdetect/task.vim scripts/vim/syntax/taskdata.vim scripts/vim/syntax/taskedit.vim scripts/zsh/_task src/Att.cpp src/Att.h src/Cmd.cpp src/Cmd.h src/Context.cpp src/Context.h src/Duration.cpp src/Duration.h src/Filter.cpp src/Filter.h src/Keymap.cpp src/Keymap.h src/Location.cpp src/Location.h src/Nibbler.cpp src/Nibbler.h src/Permission.cpp src/Permission.h src/Record.cpp src/Record.h src/Sequence.cpp src/Sequence.h src/StringTable.cpp src/StringTable.h src/Subst.cpp src/Subst.h src/Task.cpp src/Task.h src/custom.cpp src/i18n.h src/interactive.cpp src/main.cpp src/main.h src/recur.cpp src/tests/alias.t src/tests/args.t src/tests/att.t.cpp src/tests/bug.annotate.t src/tests/bug.before.t src/tests/bug.bulk.t src/tests/bug.uuid.t src/tests/cal.t src/tests/cmd.t.cpp src/tests/color.t.cpp src/tests/config.t.cpp src/tests/filt.t.cpp src/tests/fontunderline.t src/tests/nibbler.t.cpp src/tests/rc.override.t src/tests/rc.t src/tests/record.t.cpp src/tests/seq.t.cpp src/tests/stringtable.t.cpp src/tests/subst.t.cpp src/tests/util.t.cpp src/text.h src/utf8.cpp src/utf8.h src/util.h @@ -1,7 +1,10 @@ -Principal Author: - Paul Beckingham +The development of task was made possible by the significant contributions of the following people: + Paul Beckingham (Principal Author) + Federico Hernandez (Package Maintainer & Contributing Author) + David J Patrick (Designer) + John Florian (Contributing Author) -Contributing Authors: +The following submitted code, packages or analysis, and deserve special thanks: Damian Glenny Andy Lester H. İbrahim Güngör @@ -10,14 +13,12 @@ Contributing Authors: Benjamin Tegarden Chris Pride Richard Querin - Federico Hernandez T. Charles Yun - David J Patrick P.C. Shyamshankar Johan Friis Steven de Brouwer -With thanks to: +Thanks to the following, who submitted detailed bug reports and excellent suggestions: Eugene Kramer Srijith K Bruce Israel @@ -33,4 +34,6 @@ With thanks to: Eric Farris Bruce Dillahunty Askme Too + Thomas@BIC + Ian Mortimer AUTHORS @@ -1,7 +1,83 @@ ------ current release --------------------------- -1.7.0 (5/14/2009) +1.8.0 (7/21/2009) + + Added zsh tab completion script (thanks to P.C. Shyamshankar). + + Fixed bug that cause the _forcecolor configuration variable to be + considered obsolete (thank to Bruce Dillahunty). + + Fixed documentation errors (thanks to Thomas@BIC). + + The 'weekstart' configuration variable now controls the 'calendar' + report (thanks to Federico Hernandez). + + The 'displayweeknumber' configuration variable now controls the display + of week number in the 'calendar' report (thanks to Federico Hernandez). + + Supports '--' argument to indicate that all subsequence arguments are + part of the description, despite what they otherwise might mean. + + Removed support for the obsolete task file format 1 (never released). + + Fixed bug that allowed blank annotations to be added (thanks to Bruce + Dillahunty). + + Supports negative tag filters, so that (task list +foo -bar) now filters + tasks that have the "foo" tag, but do not have the "bar" tag (thanks to + Chris Pride). + + Custom reports now support a more compact form of the "age" column, + called "age_compact" (thanks to T. Charles Yun). + + Supports 'rc.name:value' for a command line override to .taskrc data + (thanks to Federico Hernandez). + + Removed obsolete DEVELOPERS file. The online support forums at + http://taskwarrior.org will provide better information. + + Fixed bug that kept some deleted tasks showing up on the calendar report + (thanks to Federico Hernandez). + + Now asks the user to confirm large changes if configuration variable + 'confirmation' is set to 'yes'. A large change is one that completely + replaces a task description, or operates on a large number of tasks, + which defaults to 4 but is configurable via the 'bulk' configuration + variable (thanks to John Florian). + + Now echoes back the new task ID on 'add' (thanks to Bruce Dillahunty). + + The new "shell" command provides an interactive shell for task. All + commands are supported (thanks to Bruce Dillahunty, Federico Hernandez, + and John Florian). + + New "recurring" report to list all recurring tasks. + + New, more flexible, more consistent, grep-able file format. + + If task is renamed to "cal", or there is a symlink to task called "cal", + then task can act as a replacement for the Unix "cal" command. + + Supports arguments to the cal command like "month year", "year", etc. + + The "tags" report now shows the tag usage count. + + The "projects" report now shows totals by project and priority. + + Now supports attribute modifiers that allow much finer control over report + filtering, for example "task list due.before:friday", or "task list + pri.not:H" and many more. + + Now supports new "age_compact" and "wait" custom report columns. + + Now supports colorization of the header and footnote messages that are + printed before and after report output, with the 'color.header' and + 'color.footnote' configuration variables. + + Now supports the 'limit' attribute, to control the number of tasks that + are shown, for example: "task list limit:10". + + Now supports a debug mode that can be used to generate helpful information + when reporting a problem. Just run the command with "task rc.debug:on ..." + and diagnostics will be generated that will help pinpoint a problem. + + The new "undo" command replaces the old "undo" and "undelete" command + with a complete undo stack that can rollback all changes. + + While waiting for a file lock, task states the reason for the delay. + + Now supports a 'waiting' state that causes tasks to not appear until + a certain date, for example "task <ID> wait:<date>". The task + will then not show up on any report (except 'all') until that date. + + The "active", "completed", "overdue" and "next" reports are now custom + reports, and therefore modifiable. + + Now supports a 'waiting' custom report to list all waiting tasks. + + Now supports a 'recurring' custom report to list all recurring tasks. + + Now supports an 'all' report to list all tasks, including deleted + + Supports command aliases - create an alias for any command by creating + a .taskrc entry like "alias.new_name=old_name". + and completed tasks. + + Now over 1,600 unit tests, helping to maintain code quality. + +------ old releases ------------------------------ + +1.7.1 (6/8/2009) + + Fixed build failure on OpenBSD (thanks to Mike Adonay). + + Took the opportunity of a patch release to update the various email + addresses and URLs in the various documents. + +1.7.0 (5/14/2009) f6b8b39d8b4a85c30a457e9e78b582b74531bfe4 + Improved the errors when parsing a corrupt or unrecognized pending.data or completed.data file (thanks to T. Charles Yun). + Added details to the "info" report about recurring tasks (thanks to T. @@ -31,16 +107,14 @@ to /usr/local/share/task (thanks to Federico Hernandez). + Applied patch to allow task to build on Arch Linux (thanks to Johan Friis). + Applied patch to fix a UUID bug on Solaris 8 (thanks to Steven de Brouwer). - + The task man page is now installed. Try "man task" (thanks to Federico - Hernandez and P.C. Shyamshankar). + + The task and taskrc man pages are here. Try "man task", "man taskrc" + (thanks to Federico Hernandez and P.C. Shyamshankar). + Fixed bug that causes task to create a default .task directory, even if data.location specified otherwise (thanks to Federico Hernandez). + New "edit" command that fires up a text editor (uses 'editor' configuration variable, $VISUAL or $EDITOR environment variable) and allows direct editing of all editable task details. ------- old releases ------------------------------ - 1.6.1 (4/24/2009) 1b6faf57c998617024d0348a87b941a5d2ab2249 + Fixed bug that caused new, first-time .taskrc files to be written without including the custom report labels (thanks to P.C. Shyamshankar). @@ -282,7 +356,7 @@ + Made unit tests compile and run again. + Removed tests from distibution. -0.9.6 (5/13/208) +0.9.6 (5/13/2008) + Corrected wrong include file in Table.cpp. + Replaced color management code. + Improved color rules code. @@ -329,7 +403,7 @@ + Rules-based colorization. 0.8.1 (1/28/2008) - 0.8.16 (3/13/2008) - + autoconf conversion (many builds). + + autoconf conversion 0.8.0 Polish (1/25/2008) + Code cleanup, reorganization. ChangeLog @@ -1,6 +1,20 @@ SUBDIRS = src -EXTRA_DIST = task_completion.sh doc/man1/task.1 doc/man5/taskrc.5 -man1_MANS = doc/man1/task.1 -man5_MANS = doc/man5/taskrc.5 -otherdir = $(datadir)/doc/task-1.7.0 -other_DATA = AUTHORS ChangeLog COPYING INSTALL NEWS README task_completion.sh + +dist_man_MANS = doc/man/task.1 doc/man/taskrc.5 doc/man/task-tutorial.5 + +docdir = $(datadir)/doc/${PACKAGE}-${VERSION} +doc_DATA = AUTHORS ChangeLog COPYING NEWS README + +EXTRA_DIST = INSTALL + +bashscriptsdir = $(docdir) +nobase_dist_bashscripts_DATA = scripts/bash/task_completion.sh + +zshscriptsdir = $(docdir) +nobase_dist_zshscripts_DATA = scripts/zsh/_task + +vimscriptsdir = $(docdir) +nobase_dist_vimscripts_DATA = scripts/vim/README scripts/vim/ftdetect/task.vim scripts/vim/syntax/taskdata.vim scripts/vim/syntax/taskedit.vim + +i18ndir = $(docdir) +nobase_dist_i18n_DATA = i18n/strings.de-DE i18n/strings.en-US i18n/strings.es-ES i18n/strings.fr-FR i18n/strings.nl-NL i18n/strings.sv-SE i18n/tips.de-DE i18n/tips.en-US i18n/tips.sv-SE Makefile.am @@ -1,41 +1,48 @@ -Welcome to Task 1.7.0. + +New Features in task 1.8.0 + + - Attribute modifiers, for precise queries + - Improved calendar feature + - Full undo capability + - All reports now customizable + - Command aliases can now be created + - In addition to being a standard part of Fedora 10 and 11 (yum install task), + task is now also a standard part of Cygwin 1.5 + - There are new demo movies on taskwarrior.org + + Please refer to the ChangeLog file for full details. There are too many to + list here. Task has been built and tested on the following configurations: - - OS X 10.4 Tiger - OS X 10.5 Leopard - - Fedora Core 8 - - Fedora Core 9 - - Fedora Core 10 - - Ubuntu 7 Feisty Fawn - - Ubuntu 8 Hardy Heron - - Ubuntu 8.10 Intrepid Ibex + - OS X 10.4 Tiger + - Fedora Core 11 Leonidas + - Fedora Core 10 Cambridge - Ubuntu 9.04 Jaunty Jackalope + - Ubuntu 8.10 Intrepid Ibex + - Ubuntu 8.04 Hardy Heron + - Slackware 12.2 - Arch Linux - - Solaris 8 - Solaris 10 + - Solaris 8 + - OpenBSD 4.5 + - FreeBSD - Cygwin 1.5.25-14 While Task has undergone testing, bugs are sure to remain. If you encounter a -bug, please contact me at task@beckingham.net. Here is what you could do, in -order of increasing effort (to you) and usefulness (to me): +bug, please enter a new issue at: - - Do nothing. Bug probably won't get fixed. + http://taskwarrior.org/projects/taskwarrior/issues/new - - Send an email to task@beckingham.net, explaining what you saw. The bug - will be addressed, and a new release will be made. You will be a hero. +Or you can also report the issue in the forums at: - - Send an email, and a reproducible test case in the form of the few commands - it takes to recreate the problem. The bug will be addressed, and a new - release will be made. You will be a hero. + http://taskwarrior.org/projects/taskwarrior/boards - - If you are a developer, send a patch that fixes the problem. Your patch - will be applied and tested, and a new release will be made. You will be a - hero. +Or just send a message to: - - Another option involves using Github's issue tracker, which can be found - at http://github.com/pbeckingham/task/issues which has the advantage that - everyone gets to see and track the issue. You will still be a hero. + support@taskwarrior.org Thank you. +--- NEWS @@ -1,55 +1,24 @@ -Thank you for taking a look at task. Task is a GTD utility featuring: - - Robust C++ implementation - - Tags - - Colorful, tabular output - - Reports, graphs - - Lots of commands - - Low-level API - - Abbreviations for all commands, options - - Multi-user file locking - - Clean architecture allowing quick addition of new features - - Recurring tasks +Thank you for taking a look at task! -It is intended that features, mainly in the form of reports will be added -frequently, with best practices and useful reports evolving from usage patterns. +Task is a GTD, todo list, task management, command line utility with a multitude +of features. It is a portable, well supported, very active project, and it is +Open Source. Task has binary distributions, online documentation, demonstration +movies, and you'll find all the details at the site: -Task is scope-limited to GTD-like functionality only. + http://taskwarrior.org -You may want to watch the old task movie on YouTube: +At the site you'll find a wiki, discussion forums, downloads, news and more. - http://www.youtube.com/watch?v=l68LCl6BYvs -or the new improved one: +Your contributions are especially welcome. Whether it comes in the form of +code patches, ideas, discussion, bug reports or just encouragement, your input +is needed. - http://www.youtube.com/watch?v=D2Kn4DMOVSw +Please send your support questions and code patches to: -Either will give you a fairly good idea of what task is capable of, and -whether it fits in to your way of working. As a command line application, -task is not for everyone and some of you may prefer to not proceed. The -movie or online tutorial file are the quickest way for you to make that -decision. The online tutorial can be found at: + support@taskwarrior.org - http://www.beckingham.net/task.html - -Task is based on ideas presented in the todo.sh script, found on: - - http://todotxt.org - -Task has many more features than todo.sh, but fundamentally, they are -both working toward the same goals, which is to help you follow basic -Getting Things Done (GTD) principles. - -All feedback is welcome, in addition to any bug reports or patches to: - - task@beckingham.net - -Or better yet, get involved in the discussion at - - http://groups.google.com/group/taskprogram - -Got an idea for an enhancement? Post a message! - -I have found that task makes me more productive and organized. -I hope task can do the same for you. +Consider joining taskwarrior.org and participating in the future of task. +--- README @@ -2,7 +2,7 @@ # Process this file with autoconf to produce a configure script. AC_PREREQ(2.61) -AC_INIT(task, 1.7.0, bugs@beckingham.net) +AC_INIT(task, 1.8.0, support@taskwarrior.org) CFLAGS="${CFLAGS=}" CXXFLAGS="${CXXFLAGS=}" @@ -10,7 +10,7 @@ CXXFLAGS="${CXXFLAGS=}" # to the configure script (./configure --enable-debug) # Check if we have enable debug support. AC_MSG_CHECKING(whether to enable debugging) -debug_default="yes" +debug_default="no" AC_ARG_ENABLE(debug, [ --enable-debug=[no/yes] turn on debugging [default=$debug_default]],, enable_debug=$debug_default) # Yes, shell scripts can be used @@ -33,7 +33,7 @@ else fi AM_INIT_AUTOMAKE -AC_CONFIG_SRCDIR([src/task.cpp]) +AC_CONFIG_SRCDIR([src/main.cpp]) AC_CONFIG_HEADER([auto.h]) # Checks for programs. configure.ac @@ -1 +1,2 @@ *.o +Makefile.in src/.gitignore @@ -32,8 +32,9 @@ #include <unistd.h> #include <stdlib.h> #include <pwd.h> -#include "task.h" #include "Config.h" +#include "text.h" +#include "util.h" //////////////////////////////////////////////////////////////////////////////// // These are default (but overridable) reports. These entries are necessary @@ -44,32 +45,7 @@ // upgrade program to make the change, or c) this. Config::Config () { - (*this)["report.long.description"] = "Lists all task, all data, matching the specified criteria"; - (*this)["report.long.columns"] = "id,project,priority,entry,start,due,recur,age,tags,description"; - (*this)["report.long.labels"] = "ID,Project,Pri,Added,Started,Due,Recur,Age,Tags,Description"; - (*this)["report.long.sort"] = "due+,priority-,project+"; - - (*this)["report.list.description"] = "Lists all tasks matching the specified criteria"; - (*this)["report.list.columns"] = "id,project,priority,due,active,age,description"; - (*this)["report.list.labels"] = "ID,Project,Pri,Due,Active,Age,Description"; - (*this)["report.list.sort"] = "due+,priority-,project+"; - - (*this)["report.ls.description"] = "Minimal listing of all tasks matching the specified criteria"; - (*this)["report.ls.columns"] = "id,project,priority,description"; - (*this)["report.ls.labels"] = "ID,Project,Pri,Description"; - (*this)["report.ls.sort"] = "priority-,project+"; - - (*this)["report.newest.description"] = "Shows the newest tasks"; - (*this)["report.newest.columns"] = "id,project,priority,due,active,age,description"; - (*this)["report.newest.labels"] = "ID,Project,Pri,Due,Active,Age,Description"; - (*this)["report.newest.sort"] = "id-"; - (*this)["report.newest.limit"] = "10"; - - (*this)["report.oldest.description"] = "Shows the oldest tasks"; - (*this)["report.oldest.columns"] = "id,project,priority,due,active,age,description"; - (*this)["report.oldest.labels"] = "ID,Project,Pri,Due,Active,Age,Description"; - (*this)["report.oldest.sort"] = "id+"; - (*this)["report.oldest.limit"] = "10"; + setDefaults (); } //////////////////////////////////////////////////////////////////////////////// @@ -92,20 +68,20 @@ bool Config::load (const std::string& file) while (getline (in, line)) { // Remove comments. - size_type pound = line.find ("#"); + std::string::size_type pound = line.find ("#"); // no i18n if (pound != std::string::npos) line = line.substr (0, pound); - line = trim (line, " \t"); + line = trim (line, " \t"); // no i18n // Skip empty lines. if (line.length () > 0) { - size_type equal = line.find ("="); + std::string::size_type equal = line.find ("="); // no i18n if (equal != std::string::npos) { - std::string key = trim (line.substr (0, equal), " \t"); - std::string value = trim (line.substr (equal+1, line.length () - equal), " \t"); + std::string key = trim (line.substr (0, equal), " \t"); // no i18n + std::string value = trim (line.substr (equal+1, line.length () - equal), " \t"); // no i18n (*this)[key] = value; } } @@ -119,112 +95,234 @@ bool Config::load (const std::string& file) } //////////////////////////////////////////////////////////////////////////////// -void Config::createDefault (const std::string& home) +void Config::createDefaultRC (const std::string& rc, const std::string& data) { - // Strip trailing slash off home directory, if necessary. - std::string terminatedHome = home; - if (home[home.length () - 1] == '/') - terminatedHome = home.substr (0, home.length () - 1); - - // Determine default names of init file and task directory. - std::string rcFile = terminatedHome + "/.taskrc"; - std::string dataDir = terminatedHome + "/.task";; - - // If rcFile is not found, offer to create one. - if (-1 == access (rcFile.c_str (), F_OK)) - { - if (confirm ( - "A configuration file could not be found in " - + rcFile - + "\n\n" - + "Would you like a sample .taskrc created, so task can proceed?")) - { - // Create a sample .taskrc file. - FILE* out; - if ((out = fopen (rcFile.c_str (), "w"))) - { - fprintf (out, "data.location=%s\n", dataDir.c_str ()); - fprintf (out, "confirmation=yes\n"); - fprintf (out, "echo.command=yes\n"); - fprintf (out, "next=2\n"); - fprintf (out, "dateformat=m/d/Y\n"); - fprintf (out, "#monthsperline=2\n"); - fprintf (out, "#defaultwidth=80\n"); - fprintf (out, "curses=on\n"); - fprintf (out, "color=on\n"); - fprintf (out, "due=7\n"); - fprintf (out, "nag=You have higher priority tasks.\n"); - fprintf (out, "locking=on\n"); - fprintf (out, "#editor=vi\n"); - - fprintf (out, "color.overdue=bold_red\n"); - fprintf (out, "color.due=bold_yellow\n"); - fprintf (out, "color.pri.H=bold\n"); - fprintf (out, "#color.pri.M=on_yellow\n"); - fprintf (out, "#color.pri.L=on_green\n"); - fprintf (out, "#color.pri.none=white on_blue\n"); - fprintf (out, "color.active=bold_cyan\n"); - fprintf (out, "color.tagged=yellow\n"); - fprintf (out, "#color.tag.bug=yellow\n"); - fprintf (out, "#color.project.garden=on_green\n"); - fprintf (out, "#color.keyword.car=on_blue\n"); - fprintf (out, "#color.recurring=on_red\n"); - fprintf (out, "#shadow.file=%s/shadow.txt\n", dataDir.c_str ()); - fprintf (out, "#shadow.command=list\n"); - fprintf (out, "#shadow.notify=on\n"); - fprintf (out, "#default.project=foo\n"); - fprintf (out, "#default.priority=M\n"); - fprintf (out, "default.command=list\n"); - - // Custom reports. - fprintf (out, "# Fields: id,uuid,project,priority,entry,start,due,recur,age,active,tags,description\n"); - fprintf (out, "# description_only\n"); - fprintf (out, "# Description: This report is ...\n"); - fprintf (out, "# Sort: due+,priority-,project+\n"); - fprintf (out, "# Filter: pro:x pri:H +bug\n"); - fprintf (out, "# Limit: 10\n"); - - fprintf (out, "report.long.description=Lists all task, all data, matching the specified criteria\n"); - fprintf (out, "report.long.labels=ID,Project,Pri,Added,Started,Due,Recur,Age,Tags,Description\n"); - fprintf (out, "report.long.columns=id,project,priority,entry,start,due,recur,age,tags,description\n"); - fprintf (out, "report.long.sort=due+,priority-,project+\n"); - - fprintf (out, "report.list.description=Lists all tasks matching the specified criteria\n"); - fprintf (out, "report.list.labels=ID,Project,Pri,Due,Active,Age,Description\n"); - fprintf (out, "report.list.columns=id,project,priority,due,active,age,description\n"); - fprintf (out, "report.list.sort=due+,priority-,project+\n"); - - fprintf (out, "report.ls.description=Minimal listing of all tasks matching the specified criteria\n"); - fprintf (out, "report.ls.labels=ID,Project,Pri,Description\n"); - fprintf (out, "report.ls.columns=id,project,priority,description\n"); - fprintf (out, "report.ls.sort=priority-,project+\n"); - - fprintf (out, "report.newest.description=Shows the newest tasks\n"); - fprintf (out, "report.newest.labels=ID,Project,Pri,Due,Active,Age,Description\n"); - fprintf (out, "report.newest.columns=id,project,priority,due,active,age,description\n"); - fprintf (out, "report.newest.sort=id-\n"); - fprintf (out, "report.newest.limit=10\n"); - - fprintf (out, "report.oldest.description=Shows the oldest tasks\n"); - fprintf (out, "report.oldest.labels=ID,Project,Pri,Due,Active,Age,Description\n"); - fprintf (out, "report.oldest.columns=id,project,priority,due,active,age,description\n"); - fprintf (out, "report.oldest.sort=id+\n"); - fprintf (out, "report.oldest.limit=10\n"); - - fclose (out); - - std::cout << "Done." << std::endl; - } - } - } + // Create a sample .taskrc file. + std::stringstream contents; + contents << "# Task program configuration file.\n" + << "# For more documentation, see http://taskwarrior.org\n" + << "\n" + << "# Files\n" + << "data.location=" << data << "\n" + << "locking=on # Use file-level locking\n" + << "\n" + << "# Terminal\n" + << "curses=on # Use ncurses library to determine terminal width\n" + << "#defaultwidth=80 # Without ncurses, assumed width\n" + << "#editor=vi # Preferred text editor\n" + << "\n" + << "# Miscellaneous\n" + << "confirmation=yes # Confirmation on delete, big changes\n" + << "echo.command=yes # Details on command just run\n" + << "next=2 # How many tasks per project in next report\n" + << "bulk=2 # > 2 tasks considered 'a lot', for confirmation\n" + << "nag=You have higher priority tasks. # Nag message to keep you honest\n" + << "\n" + << "# Dates\n" + << "dateformat=m/d/Y # Preferred input and display date format\n" + << "weekstart=Sunday # Sunday or Monday only\n" + << "displayweeknumber=yes # Show week numbers on calendar\n" + << "due=7 # Task is considered due in 7 days\n" + << "#monthsperline=2 # Number of calendar months on a line\n" + << "\n" + << "# Color controls.\n" + << "color=on # Use color\n" + << "color.overdue=bold_red # Color of overdue tasks\n" + << "color.due=bold_yellow # Color of due tasks\n" + << "color.pri.H=bold # Color of priority:H tasks\n" + << "#color.pri.M=on_yellow # Color of priority:M tasks\n" + << "#color.pri.L=on_green # Color of priority:L tasks\n" + << "#color.pri.none=white on_blue # Color of priority: tasks\n" + << "color.active=bold_cyan # Color of active tasks\n" + << "color.tagged=yellow # Color of tagged tasks\n" + << "#color.tag.bug=yellow # Color of +bug tasks\n" + << "#color.project.garden=on_green # Color of project:garden tasks\n" + << "#color.keyword.car=on_blue # Color of description.contains:car tasks\n" + << "#color.recurring=on_red # Color of recur.any: tasks\n" + << "#color.header=bold_green # Color of header messages\n" + << "#color.footnote=bold_green # Color of footnote messages\n" + << "\n" + << "#shadow.file=/tmp/shadow.txt # Location of shadow file\n" + << "#shadow.command=list # Task command for shadow file\n" + << "#shadow.notify=on # Footnote when updated\n" + << "\n" + << "#default.project=foo # Unless otherwise specified\n" + << "#default.priority=M # Unless otherwise specified\n" + << "default.command=list # Unless otherwise specified\n" + << "\n" + << "# Fields: id,uuid,project,priority,entry,start,due,recur,recur_ind,age,\n" + << "# age_compact,active,tags,description,description_only\n" + << "# Description: This report is ...\n" + << "# Sort: due+,priority-,project+\n" + << "# Filter: pro:x pri:H +bug limit:10\n" + << "\n" + << "# task long\n" + << "report.long.description=Lists all task, all data, matching the specified criteria\n" + << "report.long.columns=id,project,priority,entry,start,due,recur,age,tags,description\n" + << "report.long.labels=ID,Project,Pri,Added,Started,Due,Recur,Age,Tags,Description\n" + << "report.long.sort=due+,priority-,project+\n" + << "report.long.filter=status:pending\n" + << "\n" + << "# task list\n" + << "report.list.description=Lists all tasks matching the specified criteria\n" + << "report.list.columns=id,project,priority,due,active,age,description\n" + << "report.list.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.list.sort=due+,priority-,project+\n" + << "report.list.filter=status:pending\n" + << "\n" + << "# task ls\n" + << "report.ls.description=Minimal listing of all tasks matching the specified criteria\n" + << "report.ls.columns=id,project,priority,description\n" + << "report.ls.labels=ID,Project,Pri,Description\n" + << "report.ls.sort=priority-,project+\n" + << "report.ls.filter=status:pending\n" + << "\n" + << "# task newest\n" + << "report.newest.description=Shows the newest tasks\n" + << "report.newest.columns=id,project,priority,due,active,age,description\n" + << "report.newest.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.newest.sort=id-\n" + << "report.newest.filter=status:pending limit:10\n" + << "\n" + << "# task oldest\n" + << "report.oldest.description=Shows the oldest tasks\n" + << "report.oldest.columns=id,project,priority,due,active,age,description\n" + << "report.oldest.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.oldest.sort=id+\n" + << "report.oldest.filter=status:pending limit:10\n" + << "\n" + << "# task overdue\n" + << "report.overdue.description=Lists overdue tasks matching the specified criteria\n" + << "report.overdue.columns=id,project,priority,due,active,age,description\n" + << "report.overdue.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.overdue.sort=due+,priority-,project+\n" + << "report.overdue.filter=status:pending due.before:today\n" + << "\n" + << "# task active\n" + << "report.active.description=Lists active tasks matching the specified criteria\n" + << "report.active.columns=id,project,priority,due,active,age,description\n" + << "report.active.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.active.sort=due+,priority-,project+\n" + << "report.active.filter=status:pending start.any:\n" + << "\n" + << "# task completed\n" + << "report.completed.description=Lists completed tasks matching the specified criteria\n" + << "report.completed.columns=end,project,priority,age,description\n" + << "report.completed.labels=Complete,Project,Pri,Age,Description\n" + << "report.completed.sort=end+,priority-,project+\n" + << "report.completed.filter=status:completed\n" + << "\n" + << "# task recurring\n" + << "report.recurring.description=Lists recurring tasks matching the specified criteria\n" + << "report.recurring.columns=id,project,priority,due,recur,active,age,description\n" + << "report.recurring.labels=ID,Project,Pri,Due,Recur,Active,Age,Description\n" + << "report.recurring.sort=due+,priority-,project+\n" + << "report.recurring.filter=status:pending parent.any:\n" + << "\n" + << "# task waiting\n" + << "report.waiting.description=Lists all waiting tasks matching the specified criteria\n" + << "report.waiting.columns=id,project,priority,wait,age,description\n" + << "report.waiting.labels=ID,Project,Pri,Wait,Age,Description\n" + << "report.waiting.sort=wait+,priority-,project+\n" + << "report.waiting.filter=status:waiting\n" + << "\n" + << "# task all\n" + << "report.all.description=Lists all tasks matching the specified criteria\n" + << "report.all.columns=id,project,priority,due,active,age,description\n" + << "report.all.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.all.sort=due+,priority-,project+\n" + << "\n" + << "# task next\n" + << "report.next.description=Lists the most urgent tasks\n" + << "report.next.columns=id,project,priority,due,active,age,description\n" + << "report.next.labels=ID,Project,Pri,Due,Active,Age,Description\n" + << "report.next.sort=due+,priority-,project+\n" + << "report.next.filter=status:pending\n" + << "\n"; + + spit (rc, contents.str ()); +} - this->load (rcFile); +//////////////////////////////////////////////////////////////////////////////// +void Config::createDefaultData (const std::string& data) +{ + if (access (data.c_str (), F_OK)) + mkdir (data.c_str (), S_IRWXU); +} - // Get the data.location value from the (potentially newly created) .taskrc - // file. - dataDir = this->get ("data.location", dataDir); - if (-1 == access (dataDir.c_str (), F_OK)) - mkdir (dataDir.c_str (), S_IRWXU); +//////////////////////////////////////////////////////////////////////////////// +void Config::setDefaults () +{ + set ("report.long.description", "Lists all task, all data, matching the specified criteria"); // TODO i18n + set ("report.long.columns", "id,project,priority,entry,start,due,recur,age,tags,description"); // TODO i18n + set ("report.long.labels", "ID,Project,Pri,Added,Started,Due,Recur,Age,Tags,Description"); // TODO i18n + set ("report.long.sort", "due+,priority-,project+"); // TODO i18n + set ("report.long.filter", "status:pending"); // TODO i18n + + set ("report.list.description", "Lists all tasks matching the specified criteria"); // TODO i18n + set ("report.list.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.list.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.list.sort", "due+,priority-,project+"); // TODO i18n + set ("report.list.filter", "status:pending"); // TODO i18n + + set ("report.ls.description", "Minimal listing of all tasks matching the specified criteria"); // TODO i18n + set ("report.ls.columns", "id,project,priority,description"); // TODO i18n + set ("report.ls.labels", "ID,Project,Pri,Description"); // TODO i18n + set ("report.ls.sort", "priority-,project+"); // TODO i18n + set ("report.ls.filter", "status:pending"); // TODO i18n + + set ("report.newest.description", "Shows the newest tasks"); // TODO i18n + set ("report.newest.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.newest.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.newest.sort", "id-"); // TODO i18n + set ("report.newest.filter", "status:pending limit:10"); // TODO i18n + + set ("report.oldest.description", "Shows the oldest tasks"); // TODO i18n + set ("report.oldest.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.oldest.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.oldest.sort", "id+"); // TODO i18n + set ("report.oldest.filter", "status:pending limit:10"); // TODO i18n + + set ("report.overdue.description", "Lists overdue tasks matching the specified criteria"); // TODO i18n + set ("report.overdue.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.overdue.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.overdue.sort", "due+,priority-,project+"); // TODO i18n + set ("report.overdue.filter", "status:pending due.before:today"); // TODO i18n + + set ("report.active.description", "Lists active tasks matching the specified criteria"); // TODO i18n + set ("report.active.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.active.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.active.sort", "due+,priority-,project+"); // TODO i18n + set ("report.active.filter", "status:pending start.any:"); // TODO i18n + + set ("report.completed.description", "Lists completed tasks matching the specified criteria"); // TODO i18n + set ("report.completed.columns", "end,project,priority,age,description"); // TODO i18n + set ("report.completed.labels", "Complete,Project,Pri,Age,Description"); // TODO i18n + set ("report.completed.sort", "end+,priority-,project+"); // TODO i18n + set ("report.completed.filter", "status:completed"); // TODO i18n + + set ("report.recurring.description", "Lists recurring tasks matching the specified criteria"); // TODO i18n + set ("report.recurring.columns", "id,project,priority,due,recur,active,age,description"); // TODO i18n + set ("report.recurring.labels", "ID,Project,Pri,Due,Recur,Active,Age,Description"); // TODO i18n + set ("report.recurring.sort", "due+,priority-,project+"); // TODO i18n + set ("report.recurring.filter", "status:pending parent.any:"); // TODO i18n + + set ("report.waiting.description", "Lists all waiting tasks matching the specified criteria"); // TODO i18n + set ("report.waiting.columns", "id,project,priority,wait,age,description"); // TODO i18n + set ("report.waiting.labels", "ID,Project,Pri,Wait,Age,Description"); // TODO i18n + set ("report.waiting.sort", "wait+,priority-,project+"); // TODO i18n + set ("report.waiting.filter", "status:waiting"); // TODO i18n + + set ("report.all.description", "Lists all tasks matching the specified criteria"); // TODO i18n + set ("report.all.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.all.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.all.sort", "due+,priority-,project+"); // TODO i18n + + set ("report.next.description", "Lists the most urgent tasks"); // TODO i18n + set ("report.next.columns", "id,project,priority,due,active,age,description"); // TODO i18n + set ("report.next.labels", "ID,Project,Pri,Due,Active,Age,Description"); // TODO i18n + set ("report.next.sort", "due+,priority-,project+"); // TODO i18n + set ("report.next.filter", "status:pending"); // TODO i18n } //////////////////////////////////////////////////////////////////////////////// @@ -265,19 +363,19 @@ const std::string Config::get ( } //////////////////////////////////////////////////////////////////////////////// -bool Config::get (const std::string& key, bool default_value) +bool Config::get (const std::string& key, const bool default_value) { if ((*this).find (key) != (*this).end ()) { std::string value = lowerCase ((*this)[key]); - if (value == "t" || - value == "true" || - value == "1" || - value == "yes" || - value == "on" || - value == "enable" || - value == "enabled") + if (value == "t" || // TODO i18n + value == "true" || // TODO i18n + value == "1" || // no i18n + value == "yes" || // TODO i18n + value == "on" || // TODO i18n + value == "enable" || // TODO i18n + value == "enabled") // TODO i18n return true; return false; src/Config.cpp @@ -37,14 +37,19 @@ public: Config (); Config (const std::string&); + Config (const Config&); + Config& operator= (const Config&); + bool load (const std::string&); - void createDefault (const std::string&); + void createDefaultRC (const std::string&, const std::string&); + void createDefaultData (const std::string&); + void setDefaults (); const std::string get (const char*); const std::string get (const char*, const char*); const std::string get (const std::string&); const std::string get (const std::string&, const std::string&); - bool get (const std::string&, bool); + bool get (const std::string&, const bool); int get (const std::string&, const int); double get (const std::string&, const double); void set (const std::string&, const int); src/Config.h @@ -25,11 +25,13 @@ // //////////////////////////////////////////////////////////////////////////////// #include <iostream> +#include <sstream> #include <time.h> #include <assert.h> #include <stdlib.h> -#include "task.h" #include "Date.h" +#include "text.h" +#include "util.h" //////////////////////////////////////////////////////////////////////////////// // Defaults to "now". @@ -63,6 +65,10 @@ Date::Date (const std::string& mdy, const std::string& format /* = "m/d/Y" */) int day = 0; int year = 0; + // Perhaps it is an epoch date, in string form? + if (isEpoch (mdy)) + return; + // Before parsing according to "format", perhaps this is a relative date? if (isRelativeDate (mdy)) return; @@ -81,8 +87,8 @@ Date::Date (const std::string& mdy, const std::string& format /* = "m/d/Y" */) throw std::string ("\"") + mdy + "\" is not a valid date."; } - if (i + 1 < mdy.length () && - (mdy[i + 0] == '0' || mdy[i + 0] == '1') && + if (i + 1 < mdy.length () && + (mdy[i + 0] == '0' || mdy[i + 0] == '1') && ::isdigit (mdy[i + 1])) { month = ::atoi (mdy.substr (i, 2).c_str ()); @@ -118,7 +124,7 @@ Date::Date (const std::string& mdy, const std::string& format /* = "m/d/Y" */) // Double digit. case 'y': - if (i + 1 >= mdy.length () || + if (i + 1 >= mdy.length () || ! ::isdigit (mdy[i + 0]) || ! ::isdigit (mdy[i + 1])) { @@ -179,6 +185,9 @@ Date::Date (const std::string& mdy, const std::string& format /* = "m/d/Y" */) } } + if (i < mdy.length ()) + throw std::string ("\"") + mdy + "\" is not a valid date in " + format + " format."; + if (!valid (month, day, year)) throw std::string ("\"") + mdy + "\" is not a valid date."; @@ -209,6 +218,14 @@ time_t Date::toEpoch () } //////////////////////////////////////////////////////////////////////////////// +std::string Date::toEpochString () +{ + std::stringstream epoch; + epoch << mT; + return epoch.str (); +} + +//////////////////////////////////////////////////////////////////////////////// void Date::toEpoch (time_t& epoch) { epoch = mT; @@ -254,6 +271,22 @@ const std::string Date::toString (const std::string& format /*= "m/d/Y" */) cons } //////////////////////////////////////////////////////////////////////////////// +bool Date::valid (const std::string& input, const std::string& format) +{ + try + { + Date test (input, format); + } + + catch (...) + { + return false; + } + + return true; +} + +//////////////////////////////////////////////////////////////////////////////// bool Date::valid (const int m, const int d, const int y) { // Check that the year is valid. @@ -277,9 +310,11 @@ bool Date::leapYear (int year) { bool ly = false; - if (!(year % 4)) ly = true; - else if (!(year % 400)) ly = true; - else if (!(year % 100)) ly = false; + // (year % 4 == 0) && (year % 100 !=0) OR + // (year % 400 == 0) + // are leapyears + + if (((!(year % 4)) && (year % 100)) || (!(year % 400))) ly = true; return ly; } @@ -355,6 +390,28 @@ std::string Date::dayName (int dow) } //////////////////////////////////////////////////////////////////////////////// +int Date::weekOfYear (int weekStart) const +{ + struct tm* t = localtime (&mT); + char weekStr[3]; + + if (weekStart == 0) + strftime(weekStr, sizeof(weekStr), "%U", t); + else if (weekStart == 1) + strftime(weekStr, sizeof(weekStr), "%V", t); + else + throw std::string ("The 'weekstart' configuration variable may " + "only contain 'Sunday' or 'Monday'."); + + int weekNumber = ::atoi (weekStr); + + if (weekStart == 0) + weekNumber += 1; + + return weekNumber; +} + +//////////////////////////////////////////////////////////////////////////////// int Date::dayOfWeek () const { struct tm* t = localtime (&mT); @@ -491,6 +548,19 @@ time_t Date::operator- (const Date& rhs) } //////////////////////////////////////////////////////////////////////////////// +bool Date::isEpoch (const std::string& input) +{ + if (digitsOnly (input) && + input.length () > 8) + { + mT = (time_t) ::atoi (input.c_str ()); + return true; + } + + return false; +} + +//////////////////////////////////////////////////////////////////////////////// // If the input string looks like a relative date, determine that date, set mT // and return true. // src/Date.cpp @@ -44,8 +44,10 @@ public: void toEpoch (time_t&); time_t toEpoch (); + std::string toEpochString (); void toMDY (int&, int&, int&); const std::string toString (const std::string& format = "m/d/Y") const; + static bool valid (const std::string&, const std::string& format = "m/d/Y"); static bool valid (const int, const int, const int); static bool leapYear (int); @@ -53,11 +55,13 @@ public: static std::string monthName (int); static void dayName (int, std::string&); static std::string dayName (int); + static int weekOfYear (const std::string&); static int dayOfWeek (const std::string&); int month () const; int day () const; int year () const; + int weekOfYear (int) const; int dayOfWeek () const; bool operator== (const Date&); @@ -77,6 +81,7 @@ public: time_t operator- (const Date&); private: + bool isEpoch (const std::string&); bool isRelativeDate (const std::string&); protected: src/Date.h @@ -306,7 +306,7 @@ Grid::Cell::operator char () const { switch (mType) { - case CELL_BOOL: return mBool ? 'Y' : 'N'; + case CELL_BOOL: return mBool ? 'Y' : 'N'; // TODO i18n case CELL_CHAR: return mChar; case CELL_INT: return (char) mInt; case CELL_FLOAT: return (char) (int) mFloat; @@ -368,7 +368,7 @@ Grid::Cell::operator std::string () const switch (mType) { - case CELL_BOOL: return mBool ? "true" : "false"; + case CELL_BOOL: return mBool ? "true" : "false"; // TODO i18n case CELL_CHAR: sprintf (s, "%c", mChar); return std::string (s); case CELL_INT: sprintf (s, "%d", mInt); src/Grid.cpp @@ -45,6 +45,9 @@ public: Cell (const double); Cell (const std::string&); + Cell (const Cell&); + Cell& operator= (const Cell&); + operator bool () const; operator char () const; operator int () const; @@ -72,6 +75,9 @@ public: Grid (); ~Grid (); + Grid (const Grid&); + Grid& operator= (const Grid&); + void add (const unsigned int, const unsigned int, const bool); void add (const unsigned int, const unsigned int, const char); void add (const unsigned int, const unsigned int, const int); src/Grid.h @@ -1,2 +1,11 @@ bin_PROGRAMS = task -task_SOURCES = Config.cpp Date.cpp T.cpp TDB.cpp Table.cpp Grid.cpp Timer.cpp color.cpp parse.cpp task.cpp command.cpp edit.cpp report.cpp util.cpp text.cpp rules.cpp import.cpp Config.h Date.h T.h TDB.h Table.h Grid.h Timer.h color.h task.h +task_SOURCES = Att.cpp Cmd.cpp Config.cpp Context.cpp Date.cpp Duration.cpp \ + Filter.cpp Grid.cpp Keymap.cpp Location.cpp Nibbler.cpp \ + Record.cpp Sequence.cpp StringTable.cpp Subst.cpp Task.cpp \ + TDB.cpp Table.cpp Timer.cpp Permission.cpp color.cpp edit.cpp \ + command.cpp import.cpp interactive.cpp recur.cpp report.cpp \ + custom.cpp rules.cpp main.cpp text.cpp util.cpp \ + Att.h Cmd.h Config.h Context.h Date.h Duration.h Filter.h \ + Grid.h Keymap.h Location.h Nibbler.h Record.h Sequence.h \ + StringTable.h Subst.h Task.h TDB.h Table.h Timer.h \ + Permission.h color.h i18n.h main.h text.h util.h src/Makefile.am @@ -24,439 +24,755 @@ // USA // //////////////////////////////////////////////////////////////////////////////// + #include <iostream> -#include <fstream> #include <sstream> -#include <sys/file.h> #include <unistd.h> #include <string.h> - -#include "task.h" +#include <stdio.h> +#include <sys/file.h> +#include <stdlib.h> +#include "text.h" +#include "util.h" #include "TDB.h" +#include "Table.h" +#include "Timer.h" +#include "color.h" +#include "main.h" + +extern Context context; //////////////////////////////////////////////////////////////////////////////// +// The ctor/dtor do nothing. +// The lock/unlock methods hold the file open. +// There should be only one commit. +// +// +- TDB::TDB +// | +// | +- TDB::lock +// | | open +// | | [lock] +// | | +// | | +- TDB::load (Filter) +// | | | read all +// | | | apply filter +// | | | return subset +// | | | +// | | +- TDB::add (T) +// | | | +// | | +- TDB::update (T) +// | | | +// | | +- TDB::commit +// | | | write all +// | | | +// | | +- TDB::undo +// | | +// | +- TDB::unlock +// | [unlock] +// | close +// | +// +- TDB::~TDB +// [TDB::unlock] +// TDB::TDB () -: mPendingFile ("") -, mCompletedFile ("") +: mLock (true) +, mAllOpenAndLocked (false) , mId (1) -, mNoLock (false) { } //////////////////////////////////////////////////////////////////////////////// TDB::~TDB () { + if (mAllOpenAndLocked) + unlock (); } //////////////////////////////////////////////////////////////////////////////// -void TDB::dataDirectory (const std::string& directory) +void TDB::clear () { - if (! access (expandPath (directory).c_str (), F_OK)) - { - mPendingFile = directory + "/pending.data"; - mCompletedFile = directory + "/completed.data"; - } - else - { - std::string error = "Directory '"; - error += directory; - error += "' does not exist, or is not readable and writable."; - throw error; - } + mLocations.clear (); + mLock = true; + + if (mAllOpenAndLocked) + unlock (); + + mAllOpenAndLocked = false; + mId = 1; + mPending.clear (); + mNew.clear (); + mModified.clear (); } //////////////////////////////////////////////////////////////////////////////// -// Combine allPendingT with allCompletedT. -// Note: this method is O(N1) + O(N2), where N2 is not bounded. -bool TDB::allT (std::vector <T>& all) +void TDB::location (const std::string& path) { - all.clear (); + if (access (expandPath (path).c_str (), F_OK)) + throw std::string ("Data location '") + + path + + "' does not exist, or is not readable and writable."; - // Retrieve all the pending records. - std::vector <T> allp; - if (allPendingT (allp)) - { - std::vector <T>::iterator i; - for (i = allp.begin (); i != allp.end (); ++i) - all.push_back (*i); + mLocations.push_back (Location (path)); +} - // Retrieve all the completed records. - std::vector <T> allc; - if (allCompletedT (allc)) - { - for (i = allc.begin (); i != allc.end (); ++i) - all.push_back (*i); +//////////////////////////////////////////////////////////////////////////////// +void TDB::lock (bool lockFile /* = true */) +{ + mLock = lockFile; - return true; - } + mPending.clear (); + mNew.clear (); + mPending.clear (); + + foreach (location, mLocations) + { + location->pending = openAndLock (location->path + "/pending.data"); + location->completed = openAndLock (location->path + "/completed.data"); + location->undo = openAndLock (location->path + "/undo.data"); } - return false; + mAllOpenAndLocked = true; } //////////////////////////////////////////////////////////////////////////////// -// Only accesses to the pending file result in Tasks that have assigned ids. -bool TDB::pendingT (std::vector <T>& all) +void TDB::unlock () { - all.clear (); - - std::vector <std::string> lines; - if (readLockedFile (mPendingFile, lines)) + if (mAllOpenAndLocked) { - mId = 1; + mPending.clear (); + mNew.clear (); + mModified.clear (); - int line = 1; - std::vector <std::string>::iterator it; - for (it = lines.begin (); it != lines.end (); ++it) + foreach (location, mLocations) { - try - { - T t (*it); - t.setId (mId++); - if (t.getStatus () == T::pending) - all.push_back (t); - } - - catch (std::string& e) - { - std::stringstream more; - more << " Line " << line << ", in " << "pending.data"; + fflush (location->pending); + fclose (location->pending); + location->pending = NULL; - throw e + more.str (); - } + fflush (location->completed); + fclose (location->completed); + location->completed = NULL; - ++line; + fflush (location->undo); + fclose (location->undo); + location->completed = NULL; } - return true; + mAllOpenAndLocked = false; } - - return false; } //////////////////////////////////////////////////////////////////////////////// -// Only accesses to the pending file result in Tasks that have assigned ids. -bool TDB::allPendingT (std::vector <T>& all) +// Returns number of filtered tasks. +// Note: tasks.clear () is deliberately not called, to allow the combination of +// multiple files. +int TDB::load (std::vector <Task>& tasks, Filter& filter) { - all.clear (); - - std::vector <std::string> lines; - if (readLockedFile (mPendingFile, lines)) +#ifdef FEATURE_TDB_OPT + // Special optimization: if the filter contains Att ('status', '', 'pending'), + // and no other 'status' filters, then loadCompleted can be skipped. + int numberStatusClauses = 0; + int numberSimpleStatusClauses = 0; + foreach (att, filter) { - mId = 1; - - int line = 1; - std::vector <std::string>::iterator it; - for (it = lines.begin (); it != lines.end (); ++it) + if (att->name () == "status") { - try - { - T t (*it); - t.setId (mId++); - all.push_back (t); - } - - catch (std::string& e) - { - std::stringstream more; - more << " Line " << line << ", in " << "pending.data"; + ++numberStatusClauses; - throw e + more.str (); - } - - ++line; + if (att->mod () == "" && + (att->value () == "pending" || + att->value () == "waiting")) + ++numberSimpleStatusClauses; } - - return true; } +#endif + + loadPending (tasks, filter); + +#ifdef FEATURE_TDB_OPT + if (numberStatusClauses == 0 || + numberStatusClauses != numberSimpleStatusClauses) + loadCompleted (tasks, filter); + else + context.debug ("load optimization short circuit"); +#else + loadCompleted (tasks, filter); +#endif - return false; + return tasks.size (); } //////////////////////////////////////////////////////////////////////////////// -bool TDB::completedT (std::vector <T>& all) const +// Returns number of filtered tasks. +// Note: tasks.clear () is deliberately not called, to allow the combination of +// multiple files. +int TDB::loadPending (std::vector <Task>& tasks, Filter& filter) { - all.clear (); + Timer t ("TDB::loadPending"); - std::vector <std::string> lines; - if (readLockedFile (mCompletedFile, lines)) + std::string file; + int line_number = 1; + + try { - int line = 1; - std::vector <std::string>::iterator it; - for (it = lines.begin (); it != lines.end (); ++it) + if (mPending.size () == 0) { - try + mId = 1; + char line[T_LINE_MAX]; + foreach (location, mLocations) { - T t (*it); - if (t.getStatus () != T::deleted) - all.push_back (t); - } + line_number = 1; + file = location->path + "/pending.data"; - catch (std::string& e) - { - std::stringstream more; - more << " Line " << line << ", in " << "pending.data"; + fseek (location->pending, 0, SEEK_SET); + while (fgets (line, T_LINE_MAX, location->pending)) + { + int length = ::strlen (line); + if (length > 3) // []\n + { + // TODO Add hidden attribute indicating source? + Task task (line); + task.id = mId++; - throw e + more.str (); + mPending.push_back (task); + } + + ++line_number; + } } + } - ++line; + // Now filter and return. + foreach (task, mPending) + if (filter.pass (*task)) + tasks.push_back (*task); + + // Hand back any accumulated additions, if TDB::loadPending is being called + // repeatedly. + int fakeId = mId; + foreach (task, mNew) + { + task->id = fakeId++; + if (filter.pass (*task)) + tasks.push_back (*task); } + } - return true; + catch (std::string& e) + { + std::stringstream s; + s << " in " << file << " at line " << line_number; + throw e + s.str (); } - return false; + return tasks.size (); } //////////////////////////////////////////////////////////////////////////////// -bool TDB::allCompletedT (std::vector <T>& all) const +// Returns number of filtered tasks. +// Note: tasks.clear () is deliberately not called, to allow the combination of +// multiple files. +int TDB::loadCompleted (std::vector <Task>& tasks, Filter& filter) { - all.clear (); + Timer t ("TDB::loadCompleted"); + + std::string file; + int line_number; - std::vector <std::string> lines; - if (readLockedFile (mCompletedFile, lines)) + try { - int line = 1; - std::vector <std::string>::iterator it; - for (it = lines.begin (); it != lines.end (); ++it) + char line[T_LINE_MAX]; + foreach (location, mLocations) { - try - { - T t (*it); - all.push_back (t); - } + line_number = 1; + file = location->path + "/completed.data"; - catch (std::string& e) + fseek (location->completed, 0, SEEK_SET); + while (fgets (line, T_LINE_MAX, location->completed)) { - std::stringstream more; - more << " Line " << line << ", in " << "pending.data"; + int length = ::strlen (line); + if (length > 3) // []\n + { + // TODO Add hidden attribute indicating source? - throw e + more.str (); - } + if (line[length - 1] == '\n') + line[length - 1] = '\0'; + + Task task (line); + task.id = 0; // Need a value, just not a valid value. + + if (filter.pass (task)) + tasks.push_back (task); + } - ++line; + ++line_number; + } } + } - return true; + catch (std::string& e) + { + std::stringstream s; + s << " in " << file << " at line " << line_number; + throw e + s.str (); } - return false; + return tasks.size (); +} + +//////////////////////////////////////////////////////////////////////////////// +// Note: mLocations[0] is where all tasks are written. +void TDB::add (const Task& task) +{ + mNew.push_back (task); + +} + +//////////////////////////////////////////////////////////////////////////////// +void TDB::update (const Task& task) +{ + mModified.push_back (task); } //////////////////////////////////////////////////////////////////////////////// -bool TDB::addT (const T& t) +// Interestingly, only the pending file gets written to. The completed file is +// only modified by TDB::gc. +int TDB::commit () { - T task (t); - std::vector <std::string> tags; - task.getTags (tags); + Timer t ("TDB::commit"); + + int quantity = mNew.size () + mModified.size (); - // +tag or -tag are both considered valid tags to add to a new pending task. - // Generating an error here would not be friendly. - for (unsigned int i = 0; i < tags.size (); ++i) + // This is an optimization. If there are only new tasks, and none were + // modified, simply seek to the end of pending and write. + if (mNew.size () && ! mModified.size ()) { - if (tags[i][0] == '-' || tags[i][0] == '+') + fseek (mLocations[0].pending, 0, SEEK_END); + foreach (task, mNew) { - task.removeTag (tags[i]); - task.addTag (tags[i].substr (1, std::string::npos)); + mPending.push_back (*task); + fputs (task->composeF4 ().c_str (), mLocations[0].pending); } + + fseek (mLocations[0].undo, 0, SEEK_END); + foreach (task, mNew) + writeUndo (*task, mLocations[0].undo); + + mNew.clear (); + return quantity; } - if (task.getStatus () == T::pending || - task.getStatus () == T::recurring) + // The alternative is to potentially rewrite both files. + else if (mNew.size () || mModified.size ()) { - return writePending (task); + // allPending is a copy of mPending, with all modifications included, and + // new tasks appended. + std::vector <Task> allPending; + allPending = mPending; + foreach (task, allPending) + foreach (mtask, mModified) + if (task->id == mtask->id) + *task = *mtask; + + foreach (task, mNew) + allPending.push_back (*task); + + // Write out all pending. + if (fseek (mLocations[0].pending, 0, SEEK_SET) == 0) + { + if (ftruncate (fileno (mLocations[0].pending), 0)) + throw std::string ("Failed to truncate pending.data file "); + + foreach (task, allPending) + fputs (task->composeF4 ().c_str (), mLocations[0].pending); + } + + // Update the undo log. + if (fseek (mLocations[0].undo, 0, SEEK_END) == 0) + { + foreach (task, mPending) + foreach (mtask, mModified) + if (task->id == mtask->id) + writeUndo (*task, *mtask, mLocations[0].undo); + + foreach (task, mNew) + writeUndo (*task, mLocations[0].undo); + } + + mPending = allPending; + + mModified.clear (); + mNew.clear (); } - return writeCompleted (task); + return quantity; } //////////////////////////////////////////////////////////////////////////////// -bool TDB::modifyT (const T& t) +// Scans the pending tasks for any that are completed or deleted, and if so, +// moves them to the completed.data file. Returns a count of tasks moved. +// Now reverts expired waiting tasks to pending. +int TDB::gc () { - T modified (t); + Timer t ("TDB::gc"); + + int count = 0; + Date now; + + // Set up a second TDB. + Filter filter; + TDB tdb; + tdb.location (mLocations[0].path); + tdb.lock (); - std::vector <T> all; - allPendingT (all); + std::vector <Task> pending; + tdb.loadPending (pending, filter); - std::vector <T> pending; + std::vector <Task> completed; + tdb.loadCompleted (completed, filter); - std::vector <T>::iterator it; - for (it = all.begin (); it != all.end (); ++it) + // Now move completed and deleted tasks from the pending list to the + // completed list. Isn't garbage collection easy? + std::vector <Task> still_pending; + foreach (task, pending) { - if (it->getId () == t.getId ()) + std::string st = task->get ("status"); + Task::status s = task->getStatus (); + if (s == Task::completed || + s == Task::deleted) { - modified.setUUID (it->getUUID ()); - pending.push_back (modified); + completed.push_back (*task); + ++count; + } + else if (s == Task::waiting) + { + // Wake up tasks that are waiting. + Date wait_date (::atoi (task->get ("wait").c_str ())); + if (now > wait_date) + { + task->setStatus (Task::pending); + task->remove ("wait"); + ++count; + } + + still_pending.push_back (*task); } else - pending.push_back (*it); + still_pending.push_back (*task); } - return overwritePending (pending); + pending = still_pending; + + // No commit - all updates performed manually. + if (count > 0) + { + if (fseek (tdb.mLocations[0].pending, 0, SEEK_SET) == 0) + { + if (ftruncate (fileno (tdb.mLocations[0].pending), 0)) + throw std::string ("Failed to truncate pending.data file "); + + foreach (task, pending) + fputs (task->composeF4 ().c_str (), tdb.mLocations[0].pending); + } + + if (fseek (tdb.mLocations[0].completed, 0, SEEK_SET) == 0) + { + if (ftruncate (fileno (tdb.mLocations[0].completed), 0)) + throw std::string ("Failed to truncate completed.data file "); + + foreach (task, completed) + fputs (task->composeF4 ().c_str (), tdb.mLocations[0].completed); + } + } + + // Close files. + tdb.unlock (); + + std::stringstream s; + s << "gc " << count << " tasks"; + context.debug (s.str ()); + return count; } //////////////////////////////////////////////////////////////////////////////// -bool TDB::lock (FILE* file) const +int TDB::nextId () { - if (mNoLock) - return true; - - return flock (fileno (file), LOCK_EX) ? false : true; + return mId++; } //////////////////////////////////////////////////////////////////////////////// -bool TDB::overwritePending (std::vector <T>& all) +void TDB::undo () { - // Write a single task to the pending file - FILE* out; - if ((out = fopen (mPendingFile.c_str (), "w"))) - { - int retry = 0; - if (!mNoLock) - while (flock (fileno (out), LOCK_EX) && ++retry <= 3) - delay (0.1); + std::string location = expandPath (context.config.get ("data.location")); - std::vector <T>::iterator it; - for (it = all.begin (); it != all.end (); ++it) - fputs (it->compose ().c_str (), out); + std::string undoFile = location + "/undo.data"; + std::string pendingFile = location + "/pending.data"; + std::string completedFile = location + "/completed.data"; - fclose (out); - return true; - } + // load undo.data + std::vector <std::string> u; + slurp (undoFile, u); - return false; -} + if (u.size () < 3) + throw std::string ("There are no recorded transactions to undo."); -//////////////////////////////////////////////////////////////////////////////// -bool TDB::writePending (const T& t) -{ - // Write a single task to the pending file - FILE* out; - if ((out = fopen (mPendingFile.c_str (), "a"))) - { - int retry = 0; - if (!mNoLock) - while (flock (fileno (out), LOCK_EX) && ++retry <= 3) - delay (0.1); + // pop last tx + u.pop_back (); // separator. - fputs (t.compose ().c_str (), out); + std::string current = u.back ().substr (4, std::string::npos); + u.pop_back (); - fclose (out); - return true; + std::string prior; + std::string when; + if (u.back ().substr (0, 5) == "time ") + { + when = u.back ().substr (5, std::string::npos); + u.pop_back (); + prior = ""; + } + else + { + prior = u.back ().substr (4, std::string::npos); + u.pop_back (); + when = u.back ().substr (5, std::string::npos); + u.pop_back (); } - return false; -} - -//////////////////////////////////////////////////////////////////////////////// -bool TDB::writeCompleted (const T& t) -{ - // Write a single task to the pending file - FILE* out; - if ((out = fopen (mCompletedFile.c_str (), "a"))) + Date lastChange (::atoi (when.c_str ())); + std::cout << std::endl + << "The last modification was made " + << lastChange.toString () + << std::endl; + + // Attributes are all there is, so figure the different attribute names + // between before and after. + Table table; + table.setTableWidth (context.getWidth ()); + table.setTableIntraPadding (2); + table.addColumn (" "); + table.addColumn ("Prior Values"); + table.addColumn ("Current Values"); + table.setColumnUnderline (1); + table.setColumnUnderline (2); + table.setColumnWidth (0, Table::minimum); + table.setColumnWidth (1, Table::flexible); + table.setColumnWidth (2, Table::flexible); + + Task after (current); + + if (prior != "") { - int retry = 0; - if (!mNoLock) - while (flock (fileno (out), LOCK_EX) && ++retry <= 3) - delay (0.1); + Task before (prior); - fputs (t.compose ().c_str (), out); + std::vector <std::string> beforeAtts; + foreach (att, before) + beforeAtts.push_back (att->first); - fclose (out); - return true; - } + std::vector <std::string> afterAtts; + foreach (att, after) + afterAtts.push_back (att->first); - return false; -} + std::vector <std::string> beforeOnly; + std::vector <std::string> afterOnly; + listDiff (beforeAtts, afterAtts, beforeOnly, afterOnly); -//////////////////////////////////////////////////////////////////////////////// -bool TDB::readLockedFile ( - const std::string& file, - std::vector <std::string>& contents) const -{ - contents.clear (); + int row; + foreach (name, beforeOnly) + { + row = table.addRow (); + table.addCell (row, 0, *name); + table.addCell (row, 1, renderAttribute (*name, before.get (*name))); + table.setCellFg (row, 1, Text::red); + } - if (! access (file.c_str (), F_OK | R_OK)) - { - FILE* in; - if ((in = fopen (file.c_str (), "r"))) + foreach (name, before) { - int retry = 0; - if (!mNoLock) - while (flock (fileno (in), LOCK_EX) && ++retry <= 3) - delay (0.1); + std::string priorValue = before.get (name->first); + std::string currentValue = after.get (name->first); - char line[T_LINE_MAX]; - while (fgets (line, T_LINE_MAX, in)) + if (currentValue != "") { - int length = ::strlen (line); - if (length > 1) + row = table.addRow (); + table.addCell (row, 0, name->first); + table.addCell (row, 1, renderAttribute (name->first, priorValue)); + table.addCell (row, 2, renderAttribute (name->first, currentValue)); + + if (priorValue != currentValue) { - line[length - 1] = '\0'; // Kill \n - contents.push_back (line); + table.setCellFg (row, 1, Text::red); + table.setCellFg (row, 2, Text::green); } } + } - fclose (in); - return true; + foreach (name, afterOnly) + { + row = table.addRow (); + table.addCell (row, 0, *name); + table.addCell (row, 2, renderAttribute (*name, after.get (*name))); + table.setCellFg (row, 2, Text::green); + } + } + else + { + int row; + foreach (name, after) + { + row = table.addRow (); + table.addCell (row, 0, name->first); + table.addCell (row, 2, renderAttribute (name->first, after.get (name->first))); + table.setCellFg (row, 2, Text::green); } } - return false; -} + // Confirm. + std::cout << std::endl + << table.render () + << std::endl; -//////////////////////////////////////////////////////////////////////////////// -// Scans the pending tasks for any that are completed or deleted, and if so, -// moves them to the completed.data file. Returns a count of tasks moved. -int TDB::gc () -{ - int count = 0; + if (!confirm ("The undo command is not reversible. Are you sure you want to undo the last update?")) + throw std::string ("No changes made."); - // Read everything from the pending file. - std::vector <T> all; - allPendingT (all); + // Extract identifying uuid. + std::string uuid; + std::string::size_type uuidAtt = current.find ("uuid:\""); + if (uuidAtt != std::string::npos) + uuid = current.substr (uuidAtt, 43); // 43 = uuid:"..." + else + throw std::string ("Cannot locate UUID in task to undo."); - // A list of the truly pending tasks. - std::vector <T> pending; + // load pending.data + std::vector <std::string> p; + slurp (pendingFile, p); - std::vector<T>::iterator it; - for (it = all.begin (); it != all.end (); ++it) + // is 'current' in pending? + foreach (task, p) { - // Some tasks stay in the pending file. - if (it->getStatus () == T::pending || - it->getStatus () == T::recurring) + if (task->find (uuid) != std::string::npos) { - pending.push_back (*it); + context.debug ("TDB::undo - task found in pending.data"); + + // Either revert if there was a prior state, or remove the task. + if (prior != "") + { + *task = prior; + std::cout << "Modified task reverted." << std::endl; + } + else + { + p.erase (task); + std::cout << "Task removed." << std::endl; + } + + // Rewrite files. + spit (pendingFile, p); + spit (undoFile, u); + return; } + } - // Others are transferred to the completed file. - else + // load completed.data + std::vector <std::string> c; + slurp (completedFile, c); + + // is 'current' in completed? + foreach (task, c) + { + if (task->find (uuid) != std::string::npos) { - writeCompleted (*it); - ++count; + context.debug ("TDB::undo - task found in completed.data"); + + // If task now belongs back in pending.data + if (prior.find ("status:\"pending\"") != std::string::npos || + prior.find ("status:\"waiting\"") != std::string::npos || + prior.find ("status:\"recurring\"") != std::string::npos) + { + c.erase (task); + p.push_back (prior); + spit (completedFile, c); + spit (pendingFile, p); + spit (undoFile, u); + std::cout << "Modified task reverted." << std::endl; + context.debug ("TDB::undo - task belongs in pending.data"); + } + else + { + *task = prior; + spit (completedFile, c); + spit (undoFile, u); + std::cout << "Modified task reverted." << std::endl; + context.debug ("TDB::undo - task belongs in completed.data"); + } + + std::cout << "Undo complete." << std::endl; + return; } } - // Dump all clean tasks into pending. But don't bother unless at least one - // task was transferred. - if (count) - overwritePending (pending); - - return count; + // Perhaps user hand-edited the data files? + // Perhaps the task was in completed.data, which was still in file format 3? + std::cout << "Task with UUID " + << uuid.substr (6, 36) + << " not found in data." + << std::endl + << "No undo possible." + << std::endl; } //////////////////////////////////////////////////////////////////////////////// -int TDB::nextId () +FILE* TDB::openAndLock (const std::string& file) { - return mId++; + // TODO Need provision here for read-only locations. + + // Check for access. + bool exists = access (file.c_str (), F_OK) ? false : true; + if (exists) + if (access (file.c_str (), R_OK | W_OK)) + throw std::string ("Task does not have the correct permissions for '") + + file + "'."; + + // Open the file. + FILE* in = fopen (file.c_str (), (exists ? "r+" : "w+")); + if (!in) + throw std::string ("Could not open '") + file + "'."; + + // Lock if desired. Try three times before failing. + int retry = 0; + if (mLock) + while (flock (fileno (in), LOCK_NB | LOCK_EX) && ++retry <= 3) + { + std::cout << "Waiting for file lock..." << std::endl; + while (flock (fileno (in), LOCK_EX) && ++retry <= 3) + delay (0.2); + } + + if (retry > 3) + throw std::string ("Could not lock '") + file + "'."; + + return in; } //////////////////////////////////////////////////////////////////////////////// -void TDB::noLock () +void TDB::writeUndo (const Task& after, FILE* file) { - mNoLock = true; + Timer t ("TDB::writeUndo"); + + fprintf (file, + "time %u\nnew %s---\n", + (unsigned int) time (NULL), + after.composeF4 ().c_str ()); } //////////////////////////////////////////////////////////////////////////////// +void TDB::writeUndo (const Task& before, const Task& after, FILE* file) +{ + Timer t ("TDB::writeUndo"); + fprintf (file, + "time %u\nold %snew %s---\n", + (unsigned int) time (NULL), + before.composeF4 ().c_str (), + after.composeF4 ().c_str ()); +} + +//////////////////////////////////////////////////////////////////////////////// src/TDB.cpp @@ -27,41 +27,59 @@ #ifndef INCLUDED_TDB #define INCLUDED_TDB +#include <map> #include <vector> #include <string> -#include "T.h" +#include "Location.h" +#include "Filter.h" +#include "Task.h" + +// Length of longest line. +#define T_LINE_MAX 32768 class TDB { public: - TDB (); - ~TDB (); + TDB (); // Default constructor + ~TDB (); // Destructor + + TDB (const TDB&); + TDB& operator= (const TDB&); + + void clear (); + void location (const std::string&); + + void lock (bool lockFile = true); + void unlock (); - void dataDirectory (const std::string&); - bool allT (std::vector <T>&); - bool pendingT (std::vector <T>&); - bool allPendingT (std::vector <T>&); - bool completedT (std::vector <T>&) const; - bool allCompletedT (std::vector <T>&) const; - bool addT (const T&); - bool modifyT (const T&); - int gc (); - int nextId (); + int load (std::vector <Task>&, Filter&); + int loadPending (std::vector <Task>&, Filter&); + int loadCompleted (std::vector <Task>&, Filter&); - void noLock (); + void add (const Task&); // Single task add to pending + void update (const Task&); // Single task update to pending + int commit (); // Write out all tasks + int gc (); // Clean up pending + int nextId (); + void undo (); private: - bool lock (FILE*) const; - bool overwritePending (std::vector <T>&); - bool writePending (const T&); - bool writeCompleted (const T&); - bool readLockedFile (const std::string&, std::vector <std::string>&) const; + FILE* openAndLock (const std::string&); + void writeUndo (const Task&, FILE*); + void writeUndo (const Task&, const Task&, FILE*); private: - std::string mPendingFile; - std::string mCompletedFile; + std::vector <Location> mLocations; + bool mLock; + bool mAllOpenAndLocked; int mId; - bool mNoLock; + + std::vector <Task> mPending; // Contents of pending.data + + std::vector <Task> mNew; // Uncommitted new tasks + std::vector <Task> mModified; // Uncommitted modified tasks + + // TODO Need cache of raw file contents to preserve comments. }; #endif src/TDB.h @@ -46,9 +46,12 @@ #include <iostream> #include <string.h> #include <assert.h> -#include <Table.h> -#include <Date.h> -#include <task.h> +#include "Table.h" +#include "Date.h" +#include "Duration.h" +#include "Timer.h" +#include "text.h" +#include "util.h" //////////////////////////////////////////////////////////////////////////////// Table::Table () @@ -114,11 +117,11 @@ void Table::setTableDashedUnderline () int Table::addColumn (const std::string& col) { mSpecifiedWidth.push_back (minimum); - mMaxDataWidth.push_back (col.length ()); + mMaxDataWidth.push_back (col == "" ? 1 : col.length ()); mCalculatedWidth.push_back (0); mColumnPadding.push_back (0); - mColumns.push_back (col); + mColumns.push_back (col == "" ? " " : col); return mColumns.size () - 1; } @@ -989,7 +992,7 @@ void Table::sort (std::vector <int>& order) break; else if ((std::string)*left != "" && (std::string)*right == "") SWAP - else if (convertDuration ((std::string)*left) > convertDuration ((std::string)*right)) + else if (Duration ((std::string)*left) > Duration ((std::string)*right)) SWAP break; @@ -998,7 +1001,7 @@ void Table::sort (std::vector <int>& order) break; else if ((std::string)*left == "" && (std::string)*right != "") SWAP - else if (convertDuration ((std::string)*left) < convertDuration ((std::string)*right)) + else if (Duration ((std::string)*left) < Duration ((std::string)*right)) SWAP break; } @@ -1038,6 +1041,8 @@ void Table::clean (std::string& value) //////////////////////////////////////////////////////////////////////////////// const std::string Table::render (int maximum /* = 0 */) { + Timer t ("Table::render"); + calculateColumnWidths (); // Print column headers in column order. src/Table.cpp @@ -52,6 +52,9 @@ public: Table (); virtual ~Table (); + Table (const Table&); + Table& operator= (const Table&); + void setTableColor (Text::color, Text::color); void setTableFg (Text::color); void setTableBg (Text::color); src/Table.h @@ -26,7 +26,11 @@ //////////////////////////////////////////////////////////////////////////////// #include <iostream> #include <iomanip> -#include <Timer.h> +#include <sstream> +#include "Timer.h" +#include "Context.h" + +extern Context context; //////////////////////////////////////////////////////////////////////////////// // Timer starts when the object is constructed. @@ -37,19 +41,23 @@ Timer::Timer (const std::string& description) } //////////////////////////////////////////////////////////////////////////////// -// Timer stops when the object is desctructed. +// Timer stops when the object is destructed. Timer::~Timer () { struct timeval end; ::gettimeofday (&end, NULL); - std::cout << "Timer " - << mDescription - << " " - << std::setprecision (6) - << ((end.tv_sec - mStart.tv_sec) + - ((end.tv_usec - mStart.tv_usec ) / 1000000.0)) - << std::endl; + std::stringstream s; + s << "Timer " // No i18n + << mDescription + << " " + << std::setprecision (6) + << std::fixed + << ((end.tv_sec - mStart.tv_sec) + ((end.tv_usec - mStart.tv_usec ) + / 1000000.0)) + << " sec"; + + context.debug (s.str ()); } //////////////////////////////////////////////////////////////////////////////// src/Timer.cpp @@ -35,6 +35,8 @@ class Timer public: Timer (const std::string&); ~Timer (); + Timer (const Timer&); + Timer& operator= (const Timer&); private: std::string mDescription; src/Timer.h @@ -25,144 +25,108 @@ // //////////////////////////////////////////////////////////////////////////////// #include <string> +#include "Context.h" +#include "text.h" +#include "util.h" +#include "i18n.h" #include "color.h" +extern Context context; + //////////////////////////////////////////////////////////////////////////////// namespace Text { -std::string colorName (color c) +static struct { - switch (c) - { - case nocolor: return ""; - case off: return "off"; - - case bold: return "bold"; - case underline: return "underline"; - case bold_underline: return "bold_underline"; - - case black: return "black"; - case red: return "red"; - case green: return "green"; - case yellow: return "yellow"; - case blue: return "blue"; - case magenta: return "magenta"; - case cyan: return "cyan"; - case white: return "white"; - - case bold_black: return "bold_black"; - case bold_red: return "bold_red"; - case bold_green: return "bold_green"; - case bold_yellow: return "bold_yellow"; - case bold_blue: return "bold_blue"; - case bold_magenta: return "bold_magenta"; - case bold_cyan: return "bold_cyan"; - case bold_white: return "bold_white"; - - case underline_black: return "underline_black"; - case underline_red: return "underline_red"; - case underline_green: return "underline_green"; - case underline_yellow: return "underline_yellow"; - case underline_blue: return "underline_blue"; - case underline_magenta: return "underline_magenta"; - case underline_cyan: return "underline_cyan"; - case underline_white: return "underline_white"; - - case bold_underline_black: return "bold_underline_black"; - case bold_underline_red: return "bold_underline_red"; - case bold_underline_green: return "bold_underline_green"; - case bold_underline_yellow: return "bold_underline_yellow"; - case bold_underline_blue: return "bold_underline_blue"; - case bold_underline_magenta: return "bold_underline_magenta"; - case bold_underline_cyan: return "bold_underline_cyan"; - case bold_underline_white: return "bold_underline_white"; - - case on_black: return "on_black"; - case on_red: return "on_red"; - case on_green: return "on_green"; - case on_yellow: return "on_yellow"; - case on_blue: return "on_blue"; - case on_magenta: return "on_magenta"; - case on_cyan: return "on_cyan"; - case on_white: return "on_white"; - - case on_bright_black: return "on_bright_black"; - case on_bright_red: return "on_bright_red"; - case on_bright_green: return "on_bright_green"; - case on_bright_yellow: return "on_bright_yellow"; - case on_bright_blue: return "on_bright_blue"; - case on_bright_magenta: return "on_bright_magenta"; - case on_bright_cyan: return "on_bright_cyan"; - case on_bright_white: return "on_bright_white"; + color id; + int string_id; + std::string english_name; + std::string escape_sequence; +} allColors[] = +{ +// Text::color i18n.h English vt220? xterm? + { nocolor, 0, "", "" }, + { off, COLOR_OFF, "off", "*[0m" }, + + { bold, COLOR_BOLD, "bold", "\033[1m" }, + { underline, COLOR_UL, "underline", "\033[4m" }, + { bold_underline, COLOR_B_UL, "bold_underline", "\033[1;4m" }, + + { black, COLOR_BLACK, "black", "\033[30m" }, + { red, COLOR_RED, "red", "\033[31m" }, + { green, COLOR_GREEN, "green", "\033[32m" }, + { yellow, COLOR_YELLOW, "yellow", "\033[33m" }, + { blue, COLOR_BLUE, "blue", "\033[34m" }, + { magenta, COLOR_MAGENTA, "magenta", "\033[35m" }, + { cyan, COLOR_CYAN, "cyan", "\033[36m" }, + { white, COLOR_WHITE, "white", "\033[37m" }, + + { bold_black, COLOR_B_BLACK, "bold_black", "\033[90m" }, + { bold_red, COLOR_B_RED, "bold_red", "\033[91m" }, + { bold_green, COLOR_B_GREEN, "bold_green", "\033[92m" }, + { bold_yellow, COLOR_B_YELLOW, "bold_yellow", "\033[93m" }, + { bold_blue, COLOR_B_BLUE, "bold_blue", "\033[94m" }, + { bold_magenta, COLOR_B_MAGENTA, "bold_magenta", "\033[95m" }, + { bold_cyan, COLOR_B_CYAN, "bold_cyan", "\033[96m" }, + { bold_white, COLOR_B_WHITE, "bold_white", "\033[97m" }, + + { underline_black, COLOR_UL_BLACK, "underline_black", "\033[4;30m" }, + { underline_red, COLOR_UL_RED, "underline_red", "\033[4;31m" }, + { underline_green, COLOR_UL_GREEN, "underline_green", "\033[4;32m" }, + { underline_yellow, COLOR_UL_YELLOW, "underline_yellow", "\033[4;33m" }, + { underline_blue, COLOR_UL_BLUE, "underline_blue", "\033[4;34m" }, + { underline_magenta, COLOR_UL_MAGENTA, "underline_magenta", "\033[4;35m" }, + { underline_cyan, COLOR_UL_CYAN, "underline_cyan", "\033[4;36m" }, + { underline_white, COLOR_UL_WHITE, "underline_white", "\033[4;37m" }, + + { bold_underline_black, COLOR_B_UL_BLACK, "bold_underline_black", "\033[1;4;30m" }, + { bold_underline_red, COLOR_B_UL_RED, "bold_underline_red", "\033[1;4;31m" }, + { bold_underline_green, COLOR_B_UL_GREEN, "bold_underline_green", "\033[1;4;32m" }, + { bold_underline_yellow, COLOR_B_UL_YELLOW, "bold_underline_yellow", "\033[1;4;33m" }, + { bold_underline_blue, COLOR_B_UL_BLUE, "bold_underline_blue", "\033[1;4;34m" }, + { bold_underline_magenta, COLOR_B_UL_MAGENTA, "bold_underline_magenta", "\033[1;4;35m" }, + { bold_underline_cyan, COLOR_B_UL_CYAN, "bold_underline_cyan", "\033[1;4;36m" }, + { bold_underline_white, COLOR_B_UL_WHITE, "bold_underline_white", "\033[1;4;37m" }, + + { on_black, COLOR_ON_BLACK, "on_black", "\033[40m" }, + { on_red, COLOR_ON_RED, "on_red", "\033[41m" }, + { on_green, COLOR_ON_GREEN, "on_green", "\033[42m" }, + { on_yellow, COLOR_ON_YELLOW, "on_yellow", "\033[43m" }, + { on_blue, COLOR_ON_BLUE, "on_blue", "\033[44m" }, + { on_magenta, COLOR_ON_MAGENTA, "on_magenta", "\033[45m" }, + { on_cyan, COLOR_ON_CYAN, "on_cyan", "\033[46m" }, + { on_white, COLOR_ON_WHITE, "on_white", "\033[47m" }, + + { on_bright_black, COLOR_ON_BRIGHT_BLACK, "on_bright_black", "\033[100m" }, + { on_bright_red, COLOR_ON_BRIGHT_RED, "on_bright_red", "\033[101m" }, + { on_bright_green, COLOR_ON_BRIGHT_GREEN, "on_bright_green", "\033[102m" }, + { on_bright_yellow, COLOR_ON_BRIGHT_YELLOW, "on_bright_yellow", "\033[103m" }, + { on_bright_blue, COLOR_ON_BRIGHT_BLUE, "on_bright_blue", "\033[104m" }, + { on_bright_magenta, COLOR_ON_BRIGHT_MAGENTA, "on_bright_magenta", "\033[105m" }, + { on_bright_cyan, COLOR_ON_BRIGHT_CYAN, "on_bright_cyan", "\033[106m" }, + { on_bright_white, COLOR_ON_BRIGHT_WHITE, "on_bright_white", "\033[107m" }, +}; + +#define NUM_COLORS (sizeof (allColors) / sizeof (allColors[0])) - default: throw "Unknown Text::color value"; - } +//////////////////////////////////////////////////////////////////////////////// +std::string colorName (color c) +{ + for (unsigned int i = 0; i < NUM_COLORS; ++i) + if (allColors[i].id == c) + return allColors[i].english_name; + throw context.stringtable.get (COLOR_UNKNOWN, "Unknown color value"); return ""; } //////////////////////////////////////////////////////////////////////////////// color colorCode (const std::string& c) { - if (c == "off") return off; - else if (c == "bold") return bold; - else if (c == "underline") return underline; - else if (c == "bold_underline") return bold_underline; - - else if (c == "black") return black; - else if (c == "red") return red; - else if (c == "green") return green; - else if (c == "yellow") return yellow; - else if (c == "blue") return blue; - else if (c == "magenta") return magenta; - else if (c == "cyan") return cyan; - else if (c == "white") return white; - - else if (c == "bold_black") return bold_black; - else if (c == "bold_red") return bold_red; - else if (c == "bold_green") return bold_green; - else if (c == "bold_yellow") return bold_yellow; - else if (c == "bold_blue") return bold_blue; - else if (c == "bold_magenta") return bold_magenta; - else if (c == "bold_cyan") return bold_cyan; - else if (c == "bold_white") return bold_white; - - else if (c == "underline_black") return underline_black; - else if (c == "underline_red") return underline_red; - else if (c == "underline_green") return underline_green; - else if (c == "underline_yellow") return underline_yellow; - else if (c == "underline_blue") return underline_blue; - else if (c == "underline_magenta") return underline_magenta; - else if (c == "underline_cyan") return underline_cyan; - else if (c == "underline_white") return underline_white; - - else if (c == "bold_underline_black") return bold_underline_black; - else if (c == "bold_underline_red") return bold_underline_red; - else if (c == "bold_underline_green") return bold_underline_green; - else if (c == "bold_underline_yellow") return bold_underline_yellow; - else if (c == "bold_underline_blue") return bold_underline_blue; - else if (c == "bold_underline_magenta") return bold_underline_magenta; - else if (c == "bold_underline_cyan") return bold_underline_cyan; - else if (c == "bold_underline_white") return bold_underline_white; - - else if (c == "on_black") return on_black; - else if (c == "on_red") return on_red; - else if (c == "on_green") return on_green; - else if (c == "on_yellow") return on_yellow; - else if (c == "on_blue") return on_blue; - else if (c == "on_magenta") return on_magenta; - else if (c == "on_cyan") return on_cyan; - else if (c == "on_white") return on_white; - - else if (c == "on_bright_black") return on_bright_black; - else if (c == "on_bright_red") return on_bright_red; - else if (c == "on_bright_green") return on_bright_green; - else if (c == "on_bright_yellow") return on_bright_yellow; - else if (c == "on_bright_blue") return on_bright_blue; - else if (c == "on_bright_magenta") return on_bright_magenta; - else if (c == "on_bright_cyan") return on_bright_cyan; - else if (c == "on_bright_white") return on_bright_white; + for (unsigned int i = 0; i < NUM_COLORS; ++i) + if (context.stringtable.get (allColors[i].string_id, allColors[i].english_name) == c) + return allColors[i].id; return nocolor; } @@ -170,72 +134,11 @@ color colorCode (const std::string& c) //////////////////////////////////////////////////////////////////////////////// std::string decode (color c) { - switch (c) - { - case nocolor: return ""; - case off: return "\033[0m"; - - case bold: return "\033[1m"; - case underline: return "\033[4m"; - case bold_underline: return "\033[1;4m"; - - case black: return "\033[30m"; - case red: return "\033[31m"; - case green: return "\033[32m"; - case yellow: return "\033[33m"; - case blue: return "\033[34m"; - case magenta: return "\033[35m"; - case cyan: return "\033[36m"; - case white: return "\033[37m"; - - case bold_black: return "\033[90m"; - case bold_red: return "\033[91m"; - case bold_green: return "\033[92m"; - case bold_yellow: return "\033[93m"; - case bold_blue: return "\033[94m"; - case bold_magenta: return "\033[95m"; - case bold_cyan: return "\033[96m"; - case bold_white: return "\033[97m"; - - case underline_black: return "\033[4;30m"; - case underline_red: return "\033[4;31m"; - case underline_green: return "\033[4;32m"; - case underline_yellow: return "\033[4;33m"; - case underline_blue: return "\033[4;34m"; - case underline_magenta: return "\033[4;35m"; - case underline_cyan: return "\033[4;36m"; - case underline_white: return "\033[4;37m"; - - case bold_underline_black: return "\033[1;4;30m"; - case bold_underline_red: return "\033[1;4;31m"; - case bold_underline_green: return "\033[1;4;32m"; - case bold_underline_yellow: return "\033[1;4;33m"; - case bold_underline_blue: return "\033[1;4;34m"; - case bold_underline_magenta: return "\033[1;4;35m"; - case bold_underline_cyan: return "\033[1;4;36m"; - case bold_underline_white: return "\033[1;4;37m"; - - case on_black: return "\033[40m"; - case on_red: return "\033[41m"; - case on_green: return "\033[42m"; - case on_yellow: return "\033[43m"; - case on_blue: return "\033[44m"; - case on_magenta: return "\033[45m"; - case on_cyan: return "\033[46m"; - case on_white: return "\033[47m"; - - case on_bright_black: return "\033[100m"; - case on_bright_red: return "\033[101m"; - case on_bright_green: return "\033[102m"; - case on_bright_yellow: return "\033[103m"; - case on_bright_blue: return "\033[104m"; - case on_bright_magenta: return "\033[105m"; - case on_bright_cyan: return "\033[106m"; - case on_bright_white: return "\033[107m"; - - default: throw "Unknown Text::color value"; - } + for (unsigned int i = 0; i < NUM_COLORS; ++i) + if (allColors[i].id == c) + return allColors[i].escape_sequence; + throw context.stringtable.get (COLOR_UNKNOWN, "Unknown color value"); return ""; } @@ -262,4 +165,32 @@ std::string colorize () } //////////////////////////////////////////////////////////////////////////////// +std::string guessColor (const std::string& name) +{ + std::vector <std::string> all; + for (unsigned int i = 0; i < NUM_COLORS; ++i) + all.push_back (context.stringtable.get ( + allColors[i].string_id, + allColors[i].english_name)); + + std::vector <std::string> matches; + autoComplete (name, all, matches); + + if (matches.size () == 0) + throw std::string ("Unrecognized color '") + name + "'"; + + else if (matches.size () != 1) + { + std::string error = "Ambiguous color '" + name + "' - could be either of "; // TODO i18n + + std::string combined; + join (combined, ", ", matches); + + throw error + combined; + } + + return matches[0]; +} + +//////////////////////////////////////////////////////////////////////////////// } src/color.cpp @@ -50,6 +50,7 @@ namespace Text std::string colorize (color, color, const std::string& string); std::string colorize (color, color); std::string colorize (); + std::string guessColor (const std::string&); } #endif src/color.h @@ -24,83 +24,120 @@ // USA // //////////////////////////////////////////////////////////////////////////////// + #include <iostream> #include <iomanip> #include <sstream> #include <fstream> +#include <algorithm> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <pwd.h> #include <time.h> -#include "task.h" +#include "Permission.h" +#include "text.h" +#include "util.h" +#include "main.h" +#include "../auto.h" #ifdef HAVE_LIBNCURSES #include <ncurses.h> #endif +extern Context context; + //////////////////////////////////////////////////////////////////////////////// -std::string handleAdd (TDB& tdb, T& task, Config& conf) +std::string handleAdd () { std::stringstream out; - char entryTime[16]; - sprintf (entryTime, "%u", (unsigned int) time (NULL)); - task.setAttribute ("entry", entryTime); - - std::map <std::string, std::string> atts; - task.getAttributes (atts); - foreach (i, atts) - if (i->second == "") - task.removeAttribute (i->first); + context.task.set ("uuid", uuid ()); + context.task.setEntry (); // Recurring tasks get a special status. - if (task.getAttribute ("due") != "" && - task.getAttribute ("recur") != "") + if (context.task.has ("due") && + context.task.has ("recur")) { - task.setStatus (T::recurring); - task.setAttribute ("mask", ""); + context.task.setStatus (Task::recurring); + context.task.set ("mask", ""); } + else if (context.task.has ("wait")) + context.task.setStatus (Task::waiting); + else + context.task.setStatus (Task::pending); // Override with default.project, if not specified. - if (task.getAttribute ("project") == "") - task.setAttribute ("project", conf.get ("default.project", "")); + if (context.task.get ("project") == "") + context.task.set ("project", context.config.get ("default.project", "")); // Override with default.priority, if not specified. - if (task.getAttribute ("priority") == "") + if (context.task.get ("priority") == "") { - std::string defaultPriority = conf.get ("default.priority", ""); - if (validPriority (defaultPriority)) - task.setAttribute ("priority", defaultPriority); + std::string defaultPriority = context.config.get ("default.priority", ""); + if (Att::validNameValue ("priority", "", defaultPriority)) + context.task.set ("priority", defaultPriority); } - // Disallow blank descriptions. - if (task.getDescription () == "") - throw std::string ("Cannot add a task that is blank, or contains <CR> or <LF> characters."); + // Include tags. + foreach (tag, context.tagAdditions) + context.task.addTag (*tag); + + // Only valid tasks can be added. + context.task.validate (); - if (!tdb.addT (task)) - throw std::string ("Could not create new task."); + context.tdb.lock (context.config.get ("locking", true)); + context.tdb.add (context.task); + +#ifdef FEATURE_NEW_ID + // All this, just for an id number. + std::vector <Task> all; + Filter none; + context.tdb.loadPending (all, none); + out << "Created task " << context.tdb.nextId () << std::endl; +#endif + + context.tdb.commit (); + context.tdb.unlock (); return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleProjects (TDB& tdb, T& task, Config& conf) +std::string handleProjects () { std::stringstream out; - // Get all the tasks, including deleted ones. - std::vector <T> tasks; - tdb.pendingT (tasks); + context.filter.push_back (Att ("status", "pending")); + + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + int quantity = context.tdb.loadPending (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); // Scan all the tasks for their project name, building a map using project // names as keys. std::map <std::string, int> unique; - for (unsigned int i = 0; i < tasks.size (); ++i) + std::map <std::string, int> high; + std::map <std::string, int> medium; + std::map <std::string, int> low; + std::map <std::string, int> none; + std::string project; + std::string priority; + foreach (t, tasks) { - T task (tasks[i]); - unique[task.getAttribute ("project")] += 1; + project = t->get ("project"); + priority = t->get ("priority"); + + unique[project] += 1; + + if (priority == "H") high[project] += 1; + else if (priority == "M") medium[project] += 1; + else if (priority == "L") low[project] += 1; + else none[project] += 1; } if (unique.size ()) @@ -109,28 +146,45 @@ std::string handleProjects (TDB& tdb, T& task, Config& conf) Table table; table.addColumn ("Project"); table.addColumn ("Tasks"); + table.addColumn ("Pri:None"); + table.addColumn ("Pri:L"); + table.addColumn ("Pri:M"); + table.addColumn ("Pri:H"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("color", true) || + context.config.get (std::string ("_forcecolor"), false)) { table.setColumnUnderline (0); table.setColumnUnderline (1); + table.setColumnUnderline (2); + table.setColumnUnderline (3); + table.setColumnUnderline (4); + table.setColumnUnderline (5); } table.setColumnJustification (1, Table::right); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setColumnJustification (2, Table::right); + table.setColumnJustification (3, Table::right); + table.setColumnJustification (4, Table::right); + table.setColumnJustification (5, Table::right); foreach (i, unique) { int row = table.addRow (); table.addCell (row, 0, i->first); table.addCell (row, 1, i->second); + table.addCell (row, 2, none[i->first]); + table.addCell (row, 3, low[i->first]); + table.addCell (row, 4, medium[i->first]); + table.addCell (row, 5, high[i->first]); } - out << optionalBlankLine (conf) + out << optionalBlankLine () << table.render () - << optionalBlankLine (conf) + << optionalBlankLine () << unique.size () << (unique.size () == 1 ? " project" : " projects") + << " (" << quantity << (quantity == 1 ? " task" : " tasks") << ")" << std::endl; } else @@ -141,38 +195,95 @@ std::string handleProjects (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// -std::string handleTags (TDB& tdb, T& task, Config& conf) +std::string handleCompletionProjects () { + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + + Filter filter; + if (context.config.get (std::string ("complete.all.projects"), false)) + context.tdb.load (tasks, filter); + else + context.tdb.loadPending (tasks, filter); + + context.tdb.commit (); + context.tdb.unlock (); + + // Scan all the tasks for their project name, building a map using project + // names as keys. + std::map <std::string, int> unique; + foreach (t, tasks) + unique[t->get ("project")] = 0; + std::stringstream out; + foreach (project, unique) + if (project->first.length ()) + out << project->first << std::endl; - // Get all the tasks. - std::vector <T> tasks; - tdb.pendingT (tasks); + return out.str (); +} + +//////////////////////////////////////////////////////////////////////////////// +std::string handleTags () +{ + std::stringstream out; + + context.filter.push_back (Att ("status", "pending")); + + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + int quantity = context.tdb.loadPending (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); // Scan all the tasks for their project name, building a map using project // names as keys. - std::map <std::string, std::string> unique; - for (unsigned int i = 0; i < tasks.size (); ++i) + std::map <std::string, int> unique; + foreach (t, tasks) { - T task (tasks[i]); - std::vector <std::string> tags; - task.getTags (tags); + t->getTags (tags); - for (unsigned int t = 0; t < tags.size (); ++t) - unique[tags[t]] = ""; + foreach (tag, tags) + if (unique.find (*tag) != unique.end ()) + unique[*tag]++; + else + unique[*tag] = 1; } - // Render a list of tag names from the map. - std::cout << optionalBlankLine (conf); - foreach (i, unique) - std::cout << i->first << std::endl; - if (unique.size ()) - out << optionalBlankLine (conf) + { + // Render a list of tags names from the map. + Table table; + table.addColumn ("Tag"); + table.addColumn ("Count"); + + if (context.config.get ("color", true) || + context.config.get (std::string ("_forcecolor"), false)) + { + table.setColumnUnderline (0); + table.setColumnUnderline (1); + } + + table.setColumnJustification (1, Table::right); + + foreach (i, unique) + { + int row = table.addRow (); + table.addCell (row, 0, i->first); + table.addCell (row, 1, i->second); + } + + out << optionalBlankLine () + << table.render () + << optionalBlankLine () << unique.size () << (unique.size () == 1 ? " tag" : " tags") + << " (" << quantity << (quantity == 1 ? " task" : " tasks") << ")" << std::endl; + } else out << "No tags." << std::endl; @@ -181,98 +292,109 @@ std::string handleTags (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// -// If a task is deleted, but is still in the pending file, then it may be -// undeleted simply by changing it's status. -std::string handleUndelete (TDB& tdb, T& task, Config& conf) +std::string handleCompletionTags () { - std::stringstream out; + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); - std::vector <T> all; - tdb.allPendingT (all); - filterSequence (all, task); + Filter filter; + if (context.config.get (std::string ("complete.all.tags"), false)) + context.tdb.load (tasks, filter); + else + context.tdb.loadPending (tasks, filter); - foreach (t, all) - { - if (t->getStatus () == T::deleted) - { - if (t->getAttribute ("recur") != "") - out << "Task does not support 'undo' for recurring tasks.\n"; + context.tdb.commit (); + context.tdb.unlock (); - t->setStatus (T::pending); - t->removeAttribute ("end"); - tdb.modifyT (*t); + // Scan all the tasks for their project name, building a map using project + // names as keys. + std::map <std::string, int> unique; + foreach (t, tasks) + { + std::vector <std::string> tags; + t->getTags (tags); - out << "Task " << t->getId () << " '" << t->getDescription () << "' successfully undeleted.\n"; - } - else - { - out << "Task " << t->getId () << " '" << t->getDescription () << "' is not deleted - therefore cannot be undeleted.\n"; - } + foreach (tag, tags) + unique[*tag] = 0; } - out << "\n" - << "Please note that tasks can only be reliably undeleted if the undelete " - << "command is run immediately after the errant delete command." - << std::endl; + std::stringstream out; + foreach (tag, unique) + out << tag->first << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -// If a task is done, but is still in the pending file, then it may be undone -// simply by changing it's status. -std::string handleUndo (TDB& tdb, T& task, Config& conf) +std::string handleCompletionCommands () { + std::vector <std::string> commands; + context.cmd.allCommands (commands); + std::sort (commands.begin (), commands.end ()); + std::stringstream out; + foreach (command, commands) + out << *command << std::endl; - std::vector <T> all; - tdb.allPendingT (all); - filterSequence (all, task); + return out.str (); +} - foreach (t, all) - { - if (t->getStatus () == T::completed) - { - if (t->getAttribute ("recur") != "") - out << "Task does not support 'undo' for recurring tasks.\n"; +//////////////////////////////////////////////////////////////////////////////// +std::string handleCompletionConfig () +{ + std::vector <std::string> configs; + context.config.all (configs); + std::sort (configs.begin (), configs.end ()); - t->setStatus (T::pending); - t->removeAttribute ("end"); - tdb.modifyT (*t); + std::stringstream out; + foreach (config, configs) + out << *config << std::endl; - out << "Task " << t->getId () << " '" << t->getDescription () << "' successfully undone." << std::endl; - } - else - { - out << "Task " << t->getId () << " '" << t->getDescription () << "' is not done - therefore cannot be undone." << std::endl; - } - } + return out.str (); +} - out << std::endl - << "Please note that tasks can only be reliably undone if the undo " - << "command is run immediately after the errant done command." - << std::endl; +//////////////////////////////////////////////////////////////////////////////// +std::string handleCompletionIDs () +{ + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + context.tdb.commit (); + context.tdb.unlock (); + + std::vector <int> ids; + foreach (task, tasks) + if (task->getStatus () != Task::deleted && + task->getStatus () != Task::completed) + ids.push_back (task->id); + + std::sort (ids.begin (), ids.end ()); + + std::stringstream out; + foreach (id, ids) + out << *id << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleVersion (Config& conf) +void handleUndo () { - std::stringstream out; + context.tdb.lock (context.config.get ("locking", true)); + context.tdb.undo (); + context.tdb.unlock (); +} - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif +//////////////////////////////////////////////////////////////////////////////// +std::string handleVersion () +{ + std::stringstream out; // Create a table for the disclaimer. + int width = context.getWidth (); Table disclaimer; disclaimer.setTableWidth (width); disclaimer.addColumn (" "); @@ -290,79 +412,87 @@ std::string handleVersion (Config& conf) link.setColumnWidth (0, Table::flexible); link.setColumnJustification (0, Table::left); link.addCell (link.addRow (), 0, - "See http://www.beckingham.net/task.html for the latest releases and a " - "full tutorial. New releases containing fixes and enhancements are " - "made frequently."); + "See http://taskwarrior.org for the latest releases, online documentation " + "and lively discussion. New releases containing fixes and enhancements " + "are made frequently."); + + std::vector <std::string> all; + context.config.all (all); // Create a table for output. Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - table.addColumn ("Config variable"); - table.addColumn ("Value"); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("longversion", true)) { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - } - else - table.setTableDashedUnderline (); + table.setTableWidth (width); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); + table.addColumn ("Config variable"); + table.addColumn ("Value"); + + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) + { + table.setColumnUnderline (0); + table.setColumnUnderline (1); + } + else + table.setTableDashedUnderline (); - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::flexible); - table.setColumnJustification (0, Table::left); - table.setColumnJustification (1, Table::left); - table.sortOn (0, Table::ascendingCharacter); + table.setColumnWidth (0, Table::minimum); + table.setColumnWidth (1, Table::flexible); + table.setColumnJustification (0, Table::left); + table.setColumnJustification (1, Table::left); + table.sortOn (0, Table::ascendingCharacter); - std::vector <std::string> all; - conf.all (all); - foreach (i, all) - { - std::string value = conf.get (*i); - if (value != "") + foreach (i, all) { - int row = table.addRow (); - table.addCell (row, 0, *i); - table.addCell (row, 1, value); + std::string value = context.config.get (*i); + if (value != "") + { + int row = table.addRow (); + table.addCell (row, 0, *i); + table.addCell (row, 1, value); + } } } out << "Copyright (C) 2006 - 2009, P. Beckingham." << std::endl - << ((conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + << ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) ? Text::colorize (Text::bold, Text::nocolor, PACKAGE) : PACKAGE) << " " - << ((conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + << ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) ? Text::colorize (Text::bold, Text::nocolor, VERSION) : VERSION) << std::endl << disclaimer.render () << std::endl - << table.render () + << (context.config.get ("longversion", true) ? table.render () : "") << link.render () << std::endl; // Complain about configuration variables that are not recognized. // These are the regular configuration variables. - // Note that there is a leading and trailing space. + // Note that there is a leading and trailing space, to make searching easier. std::string recognized = - " blanklines color color.active color.due color.overdue color.pri.H " + " blanklines bulk color color.active color.due color.overdue color.pri.H " "color.pri.L color.pri.M color.pri.none color.recurring color.tagged " - "confirmation curses data.location dateformat default.command " - "default.priority defaultwidth due echo.command locking monthsperline nag " - "next project shadow.command shadow.file shadow.notify weekstart editor " - "import.synonym.id import.synonym.uuid import.synonym.status " - "import.synonym.tags import.synonym.entry import.synonym.start " - "import.synonym.due import.synonym.recur import.synonym.end " - "import.synonym.project import.synonym.priority import.synonym.fg " - "import.synonym.bg import.synonym.description "; + "color.footnote color.header color.debug confirmation curses data.location " + "dateformat debug default.command default.priority defaultwidth due locale " + "displayweeknumber echo.command locking monthsperline nag next project " + "shadow.command shadow.file shadow.notify weekstart editor import.synonym.id " + "import.synonym.uuid longversion complete.all.projects complete.all.tags " +#ifdef FEATURE_SHELL + "shell.prompt " +#endif + "import.synonym.status import.synonym.tags import.synonym.entry " + "import.synonym.start import.synonym.due import.synonym.recur " + "import.synonym.end import.synonym.project import.synonym.priority " + "import.synonym.fg import.synonym.bg import.synonym.description "; // This configuration variable is supported, but not documented. It exists // so that unit tests can force color to be on even when the output from task // is redirected to a file, or stdout is not a tty. - recognized += " _forcecolor"; + recognized += "_forcecolor "; std::vector <std::string> unrecognized; foreach (i, all) @@ -374,10 +504,11 @@ std::string handleVersion (Config& conf) { // These are special configuration variables, because their name is // dynamic. - if (i->find ("color.keyword.") == std::string::npos && - i->find ("color.project.") == std::string::npos && - i->find ("color.tag.") == std::string::npos && - i->find ("report.") == std::string::npos) + if (i->substr (0, 14) != "color.keyword." && + i->substr (0, 14) != "color.project." && + i->substr (0, 10) != "color.tag." && + i->substr (0, 7) != "report." && + i->substr (0, 6) != "alias.") { unrecognized.push_back (*i); } @@ -403,12 +534,12 @@ std::string handleVersion (Config& conf) << std::endl; else { - if (conf.get ("data.location") == "") + if (context.config.get ("data.location") == "") out << "Configuration error: data.location not specified in .taskrc " "file." << std::endl; - if (access (expandPath (conf.get ("data.location")).c_str (), X_OK)) + if (access (expandPath (context.config.get ("data.location")).c_str (), X_OK)) out << "Configuration error: data.location contains a directory name" " that doesn't exist, or is unreadable." << std::endl; @@ -418,32 +549,38 @@ std::string handleVersion (Config& conf) } //////////////////////////////////////////////////////////////////////////////// -std::string handleDelete (TDB& tdb, T& task, Config& conf) +std::string handleDelete () { std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); - filterSequence (all, task); + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + std::vector <Task> all = tasks; + context.filter.applySequence (tasks, context.sequence); // Determine the end date. char endTime[16]; sprintf (endTime, "%u", (unsigned int) time (NULL)); - foreach (t, all) + foreach (task, tasks) { std::stringstream question; question << "Permanently delete task " - << t->getId () + << task->id << " '" - << t->getDescription () + << task->get ("description") << "'?"; - if (!conf.get (std::string ("confirmation"), false) || confirm (question.str ())) + if (!context.config.get (std::string ("confirmation"), false) || confirm (question.str ())) { // Check for the more complex case of a recurring task. If this is a // recurring task, get confirmation to delete them all. - std::string parent = t->getAttribute ("parent"); + std::string parent = task->get ("parent"); if (parent != "") { if (confirm ("This is a recurring task. Do you want to delete all pending recurrences of this same task?")) @@ -452,18 +589,18 @@ std::string handleDelete (TDB& tdb, T& task, Config& conf) // itself, and delete them. foreach (sibling, all) { - if (sibling->getAttribute ("parent") == parent || - sibling->getUUID () == parent) + if (sibling->get ("parent") == parent || + sibling->get ("uuid") == parent) { - sibling->setStatus (T::deleted); - sibling->setAttribute ("end", endTime); - tdb.modifyT (*sibling); + sibling->setStatus (Task::deleted); + sibling->set ("end", endTime); + context.tdb.update (*sibling); - if (conf.get ("echo.command", true)) + if (context.config.get ("echo.command", true)) out << "Deleting recurring task " - << sibling->getId () + << sibling->id << " '" - << sibling->getDescription () + << sibling->get ("description") << "'" << std::endl; } @@ -472,31 +609,31 @@ std::string handleDelete (TDB& tdb, T& task, Config& conf) else { // Update mask in parent. - t->setStatus (T::deleted); - updateRecurrenceMask (tdb, all, *t); + task->setStatus (Task::deleted); + updateRecurrenceMask (all, *task); - t->setAttribute ("end", endTime); - tdb.modifyT (*t); + task->set ("end", endTime); + context.tdb.update (*task); out << "Deleting recurring task " - << t->getId () + << task->id << " '" - << t->getDescription () + << task->get ("description") << "'" << std::endl; } } else { - t->setStatus (T::deleted); - t->setAttribute ("end", endTime); - tdb.modifyT (*t); + task->setStatus (Task::deleted); + task->set ("end", endTime); + context.tdb.update (*task); - if (conf.get ("echo.command", true)) + if (context.config.get ("echo.command", true)) out << "Deleting task " - << t->getId () + << task->id << " '" - << t->getDescription () + << task->get ("description") << "'" << std::endl; } @@ -505,128 +642,188 @@ std::string handleDelete (TDB& tdb, T& task, Config& conf) out << "Task not deleted." << std::endl; } + context.tdb.commit (); + context.tdb.unlock (); + return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleStart (TDB& tdb, T& task, Config& conf) +std::string handleStart () { std::stringstream out; - std::vector <T> all; - tdb.pendingT (all); - filterSequence (all, task); + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); - foreach (t, all) + // Filter sequence. + context.filter.applySequence (tasks, context.sequence); + + bool nagged = false; + foreach (task, tasks) { - if (t->getAttribute ("start") == "") + if (! task->has ("start")) { char startTime[16]; sprintf (startTime, "%u", (unsigned int) time (NULL)); - t->setAttribute ("start", startTime); + task->set ("start", startTime); - tdb.modifyT (*t); + context.tdb.update (*task); - if (conf.get ("echo.command", true)) + if (context.config.get ("echo.command", true)) out << "Started " - << t->getId () + << task->id << " '" - << t->getDescription () + << task->get ("description") << "'" << std::endl; - nag (tdb, task, conf); + if (!nagged) + nagged = nag (*task); } else { - out << "Task " << t->getId () << " '" << t->getDescription () << "' already started." << std::endl; + out << "Task " + << task->id + << " '" + << task->get ("description") + << "' already started." + << std::endl; } } + context.tdb.commit (); + context.tdb.unlock (); + return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleStop (TDB& tdb, T& task, Config& conf) +std::string handleStop () { std::stringstream out; - std::vector <T> all; - tdb.pendingT (all); - filterSequence (all, task); + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + context.filter.applySequence (tasks, context.sequence); - foreach (t, all) + foreach (task, tasks) { - if (t->getAttribute ("start") != "") + if (task->has ("start")) { - t->removeAttribute ("start"); - tdb.modifyT (*t); + task->remove ("start"); + context.tdb.update (*task); - if (conf.get ("echo.command", true)) - out << "Stopped " << t->getId () << " '" << t->getDescription () << "'" << std::endl; + if (context.config.get ("echo.command", true)) + out << "Stopped " + << task->id + << " '" + << task->get ("description") + << "'" + << std::endl; } else { - out << "Task " << t->getId () << " '" << t->getDescription () << "' not started." << std::endl; + out << "Task " + << task->id + << " '" + << task->get ("description") + << "' not started." + << std::endl; } } + context.tdb.commit (); + context.tdb.unlock (); + return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleDone (TDB& tdb, T& task, Config& conf) +std::string handleDone () { int count = 0; std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); - std::vector <T> filtered = all; - filterSequence (filtered, task); - foreach (seq, filtered) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + std::vector <Task> all = tasks; + context.filter.applySequence (tasks, context.sequence); + + Permission permission; + if (context.sequence.size () > (size_t) context.config.get ("bulk", 2)) + permission.bigSequence (); + + bool nagged = false; + foreach (task, tasks) { - if (seq->getStatus () == T::pending) + if (task->getStatus () == Task::pending) { - // Apply deltas. - deltaDescription (*seq, task); - deltaTags (*seq, task); - deltaAttributes (*seq, task); - deltaSubstitutions (*seq, task); + Task before (*task); + + // Apply other deltas. + if (deltaDescription (*task)) + permission.bigChange (); + + deltaTags (*task); + deltaAttributes (*task); + deltaSubstitutions (*task); // Add an end date. char entryTime[16]; sprintf (entryTime, "%u", (unsigned int) time (NULL)); - seq->setAttribute ("end", entryTime); + task->set ("end", entryTime); // Change status. - seq->setStatus (T::completed); + task->setStatus (Task::completed); - if (!tdb.modifyT (*seq)) - throw std::string ("Could not mark task as completed."); - - if (conf.get ("echo.command", true)) - out << "Completed " - << seq->getId () - << " '" - << seq->getDescription () - << "'" - << std::endl; + if (taskDiff (before, *task)) + { + if (permission.confirmed (before, taskDifferences (before, *task) + "Are you sure?")) + { + context.tdb.update (*task); + + if (context.config.get ("echo.command", true)) + out << "Completed " + << task->id + << " '" + << task->get ("description") + << "'" + << std::endl; - updateRecurrenceMask (tdb, all, *seq); - nag (tdb, *seq, conf); + ++count; + } + } - ++count; + updateRecurrenceMask (all, *task); + if (!nagged) + nagged = nag (*task); } else out << "Task " - << seq->getId () + << task->id << " '" - << seq->getDescription () + << task->get ("description") << "' is not pending" << std::endl; } - if (conf.get ("echo.command", true)) + context.tdb.commit (); + context.tdb.unlock (); + + if (context.config.get ("echo.command", true)) out << "Marked " << count << " task" @@ -638,229 +835,345 @@ std::string handleDone (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// -std::string handleExport (TDB& tdb, T& task, Config& conf) +std::string handleExport () { - std::stringstream output; + std::stringstream out; - // Use the description as a file name, then clobber the description so the - // file name isn't used for filtering. - std::string file = trim (task.getDescription ()); - task.setDescription (""); + // Deliberately no 'id'. + out << "'uuid'," + << "'status'," + << "'tags'," + << "'entry'," + << "'start'," + << "'due'," + << "'recur'," + << "'end'," + << "'project'," + << "'priority'," + << "'fg'," + << "'bg'," + << "'description'" + << "\n"; - if (file.length () > 0) + int count = 0; + + // Get all the tasks. + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); + + foreach (task, tasks) { - std::ofstream out (file.c_str ()); - if (out.good ()) + if (task->getStatus () != Task::recurring) { - out << "'id'," - << "'uuid'," - << "'status'," - << "'tags'," - << "'entry'," - << "'start'," - << "'due'," - << "'recur'," - << "'end'," - << "'project'," - << "'priority'," - << "'fg'," - << "'bg'," - << "'description'" - << "\n"; - - int count = 0; - std::vector <T> all; - tdb.allPendingT (all); - filter (all, task); - foreach (t, all) - { - if (t->getStatus () != T::recurring && - t->getStatus () != T::deleted) - { - out << t->composeCSV ().c_str (); - ++count; - } - } - out.close (); - - output << count << " tasks exported to '" << file << "'" << std::endl; + out << task->composeCSV ().c_str (); + ++count; } - else - throw std::string ("Could not write to export file."); } - else - throw std::string ("You must specify a file to write to."); - return output.str (); + return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleModify (TDB& tdb, T& task, Config& conf) +std::string handleModify () { int count = 0; std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); - std::vector <T> filtered = all; - filterSequence (filtered, task); - foreach (seq, filtered) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + std::vector <Task> all = tasks; + context.filter.applySequence (tasks, context.sequence); + + Permission permission; + if (context.sequence.size () > (size_t) context.config.get ("bulk", 2)) + permission.bigSequence (); + + foreach (task, tasks) { // Perform some logical consistency checks. - if (task.getAttribute ("recur") != "" && - task.getAttribute ("due") == "" && - seq->getAttribute ("due") == "") + if (context.task.has ("recur") && + !context.task.has ("due") && + !task->has ("due")) throw std::string ("You cannot specify a recurring task without a due date."); - if (task.getAttribute ("until") != "" && - task.getAttribute ("recur") == "" && - seq->getAttribute ("recur") == "") + if (context.task.has ("until") && + !context.task.has ("recur") && + !task->has ("recur")) throw std::string ("You cannot specify an until date for a non-recurring task."); // Make all changes. foreach (other, all) { - if (other->getId () == seq->getId () || // Self - (seq->getAttribute ("parent") != "" && - seq->getAttribute ("parent") == other->getAttribute ("parent")) || // Sibling - other->getUUID () == seq->getAttribute ("parent")) // Parent + if (other->id == task->id || // Self + (task->has ("parent") && + task->get ("parent") == other->get ("parent")) || // Sibling + other->get ("uuid") == task->get ("parent")) // Parent { + Task before (*other); + // A non-zero value forces a file write. int changes = 0; // Apply other deltas. - changes += deltaDescription (*other, task); - changes += deltaTags (*other, task); - changes += deltaAttributes (*other, task); - changes += deltaSubstitutions (*other, task); + if (deltaDescription (*other)) + { + permission.bigChange (); + ++changes; + } - if (changes) - tdb.modifyT (*other); + changes += deltaTags (*other); + changes += deltaAttributes (*other); + changes += deltaSubstitutions (*other); - ++count; + if (taskDiff (before, *other)) + { + if (changes && permission.confirmed (before, taskDifferences (before, *other) + "Are you sure?")) + { + context.tdb.update (*other); + ++count; + } + } } } } - if (conf.get ("echo.command", true)) + context.tdb.commit (); + context.tdb.unlock (); + + if (context.config.get ("echo.command", true)) out << "Modified " << count << " task" << (count == 1 ? "" : "s") << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleAppend (TDB& tdb, T& task, Config& conf) +std::string handleAppend () { int count = 0; std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); - std::vector <T> filtered = all; - filterSequence (filtered, task); - foreach (seq, filtered) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + std::vector <Task> all = tasks; + context.filter.applySequence (tasks, context.sequence); + + Permission permission; + if (context.sequence.size () > (size_t) context.config.get ("bulk", 2)) + permission.bigSequence (); + + foreach (task, tasks) { foreach (other, all) { - if (other->getId () == seq->getId () || // Self - (seq->getAttribute ("parent") != "" && - seq->getAttribute ("parent") == other->getAttribute ("parent")) || // Sibling - other->getUUID () == seq->getAttribute ("parent")) // Parent + if (other->id == task->id || // Self + (task->has ("parent") && + task->get ("parent") == other->get ("parent")) || // Sibling + other->get ("uuid") == task->get ("parent")) // Parent { + Task before (*other); + // A non-zero value forces a file write. int changes = 0; // Apply other deltas. - changes += deltaAppend (*other, task); - changes += deltaTags (*other, task); - changes += deltaAttributes (*other, task); + changes += deltaAppend (*other); + changes += deltaTags (*other); + changes += deltaAttributes (*other); - if (changes) + if (taskDiff (before, *other)) { - tdb.modifyT (*other); + if (changes && permission.confirmed (before, taskDifferences (before, *other) + "Are you sure?")) + { + context.tdb.update (*other); - if (conf.get ("echo.command", true)) - out << "Appended '" - << task.getDescription () - << "' to task " - << other->getId () - << std::endl; - } + if (context.config.get ("echo.command", true)) + out << "Appended '" + << context.task.get ("description") + << "' to task " + << other->id + << std::endl; - ++count; + ++count; + } + } } } } - if (conf.get ("echo.command", true)) + context.tdb.commit (); + context.tdb.unlock (); + + if (context.config.get ("echo.command", true)) out << "Appended " << count << " task" << (count == 1 ? "" : "s") << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleDuplicate (TDB& tdb, T& task, Config& conf) +std::string handleDuplicate () { - int count = 0; std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); + int count = 0; - std::vector <T> filtered = all; - filterSequence (filtered, task); - foreach (seq, filtered) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + context.filter.applySequence (tasks, context.sequence); + + foreach (task, tasks) { - if (seq->getStatus () != T::recurring && seq->getAttribute ("parent") == "") + Task dup (*task); + dup.set ("uuid", uuid ()); // Needs a new UUID. + dup.setStatus (Task::pending); + dup.remove ("start"); // Does not inherit start date. + dup.remove ("end"); // Does not inherit end date. + + // Recurring tasks are duplicated and downgraded to regular tasks. + if (task->getStatus () == Task::recurring) { - T dup (*seq); - dup.setUUID (uuid ()); // Needs a new UUID. + dup.remove ("parent"); + dup.remove ("recur"); + dup.remove ("until"); + dup.remove ("imak"); + dup.remove ("imask"); + + out << "Note: task " + << task->id + << " was a recurring task. The new task is not." + << std::endl; + } - // Apply deltas. - deltaDescription (dup, task); - deltaTags (dup, task); - deltaAttributes (dup, task); - deltaSubstitutions (dup, task); + // Apply deltas. + deltaDescription (dup); + deltaTags (dup); + deltaAttributes (dup); + deltaSubstitutions (dup); - // A New task needs a new entry time. - char entryTime[16]; - sprintf (entryTime, "%u", (unsigned int) time (NULL)); - dup.setAttribute ("entry", entryTime); + // A New task needs a new entry time. + char entryTime[16]; + sprintf (entryTime, "%u", (unsigned int) time (NULL)); + dup.set ("entry", entryTime); - if (!tdb.addT (dup)) - throw std::string ("Could not create new task."); + context.tdb.add (dup); - if (conf.get ("echo.command", true)) - out << "Duplicated " - << seq->getId () - << " '" - << seq->getDescription () - << "'" - << std::endl; - ++count; - } - else - out << "Task " - << seq->getId () + if (context.config.get ("echo.command", true)) + out << "Duplicated " + << task->id << " '" - << seq->getDescription () - << "' is a recurring task, and cannot be duplicated." + << task->get ("description") + << "'" << std::endl; + ++count; } - if (conf.get ("echo.command", true)) + context.tdb.commit (); + context.tdb.unlock (); + + if (context.config.get ("echo.command", true)) out << "Duplicated " << count << " task" << (count == 1 ? "" : "s") << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleColor (Config& conf) +#ifdef FEATURE_SHELL +void handleShell () { - std::stringstream out; + // Display some kind of welcome message. + std::cout << ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) + ? Text::colorize (Text::bold, Text::nocolor, PACKAGE_STRING) + : PACKAGE_STRING) + << " shell" + << std::endl + << std::endl + << "Enter any task command (such as 'list'), or hit 'Enter'." + << std::endl + << "There is no need to include the 'task' command itself." + << std::endl + << "Enter 'quit' to end the session." + << std::endl + << std::endl; + + // Preserve any special override arguments, and reapply them for each + // shell command. + std::vector <std::string> special; + foreach (arg, context.args) + if (arg->substr (0, 3) == "rc." || + arg->substr (0, 3) == "rc:") + special.push_back (*arg); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + std::string quit = "quit"; // TODO i18n + std::string command; + bool keepGoing = true; + + do { - out << optionalBlankLine (conf) << "Foreground" << std::endl + std::cout << context.config.get ("shell.prompt", "task>") << " "; + + command = ""; + std::getline (std::cin, command); + command = lowerCase (trim (command)); + + if (command.length () > 0 && + command.length () <= quit.length () && + command == quit.substr (0, command.length ())) + { + keepGoing = false; + } + else + { + try + { + context.clear (); + + std::vector <std::string> args; + split (args, command, ' '); + foreach (arg, special) context.args.push_back (*arg); + foreach (arg, args) context.args.push_back (*arg); + + context.initialize (); + context.run (); + } + + catch (std::string& error) + { + std::cout << error << std::endl; + } + + catch (...) + { + std::cerr << context.stringtable.get (100, "Unknown error.") << std::endl; + } + } + } + while (keepGoing && !std::cin.eof ()); +} +#endif + +//////////////////////////////////////////////////////////////////////////////// +std::string handleColor () +{ + std::stringstream out; + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) + { + out << optionalBlankLine () << "Foreground" << std::endl << " " << Text::colorize (Text::bold, Text::nocolor, "bold") << " " << Text::colorize (Text::underline, Text::nocolor, "underline") << " " @@ -907,86 +1220,97 @@ std::string handleColor (Config& conf) << Text::colorize (Text::bold_underline_white, Text::nocolor, "bold_underline_white") << std::endl << std::endl << "Background" << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_black, "on_black") << " " - << Text::colorize (Text::nocolor, Text::on_bright_black, "on_bright_black") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_black, "on_black") << " " + << Text::colorize (Text::nocolor, Text::on_bright_black, "on_bright_black") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_red, "on_red") << " " - << Text::colorize (Text::nocolor, Text::on_bright_red, "on_bright_red") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_red, "on_red") << " " + << Text::colorize (Text::nocolor, Text::on_bright_red, "on_bright_red") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_green, "on_green") << " " - << Text::colorize (Text::nocolor, Text::on_bright_green, "on_bright_green") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_green, "on_green") << " " + << Text::colorize (Text::nocolor, Text::on_bright_green, "on_bright_green") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_yellow, "on_yellow") << " " - << Text::colorize (Text::nocolor, Text::on_bright_yellow, "on_bright_yellow") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_yellow, "on_yellow") << " " + << Text::colorize (Text::nocolor, Text::on_bright_yellow, "on_bright_yellow") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_blue, "on_blue") << " " - << Text::colorize (Text::nocolor, Text::on_bright_blue, "on_bright_blue") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_blue, "on_blue") << " " + << Text::colorize (Text::nocolor, Text::on_bright_blue, "on_bright_blue") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_magenta, "on_magenta") << " " - << Text::colorize (Text::nocolor, Text::on_bright_magenta, "on_bright_magenta") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_magenta, "on_magenta") << " " + << Text::colorize (Text::nocolor, Text::on_bright_magenta, "on_bright_magenta") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_cyan, "on_cyan") << " " - << Text::colorize (Text::nocolor, Text::on_bright_cyan, "on_bright_cyan") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_cyan, "on_cyan") << " " + << Text::colorize (Text::nocolor, Text::on_bright_cyan, "on_bright_cyan") << std::endl - << " " << Text::colorize (Text::nocolor, Text::on_white, "on_white") << " " - << Text::colorize (Text::nocolor, Text::on_bright_white, "on_bright_white") << std::endl + << " " << Text::colorize (Text::nocolor, Text::on_white, "on_white") << " " + << Text::colorize (Text::nocolor, Text::on_bright_white, "on_bright_white") << std::endl - << optionalBlankLine (conf); + << optionalBlankLine (); } else { - out << "Color is currently turned off in your .taskrc file." << std::endl; + out << "Color is currently turned off in your .taskrc file. " + "To enable color, create the entry 'color=on'." + << std::endl; } return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleAnnotate (TDB& tdb, T& task, Config& conf) +std::string handleAnnotate () { + if (!context.task.has ("description")) + throw std::string ("Cannot apply a blank annotation."); + std::stringstream out; - std::vector <T> all; - tdb.pendingT (all); - filterSequence (all, task); - foreach (t, all) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + context.filter.applySequence (tasks, context.sequence); + + Permission permission; + if (context.sequence.size () > (size_t) context.config.get ("bulk", 2)) + permission.bigSequence (); + + foreach (task, tasks) { - t->addAnnotation (task.getDescription ()); - tdb.modifyT (*t); - - if (conf.get ("echo.command", true)) - out << "Annotated " - << t->getId () - << " with '" - << t->getDescription () - << "'" - << std::endl; - } + Task before (*task); + task->addAnnotation (context.task.get ("description")); - return out.str (); -} + if (taskDiff (before, *task)) + { + if (permission.confirmed (before, taskDifferences (before, *task) + "Are you sure?")) + { + context.tdb.update (*task); -//////////////////////////////////////////////////////////////////////////////// -T findT (int id, const std::vector <T>& all) -{ - std::vector <T>::const_iterator it; - for (it = all.begin (); it != all.end (); ++it) - if (id == it->getId ()) - return *it; + if (context.config.get ("echo.command", true)) + out << "Annotated " + << task->id + << " with '" + << context.task.get ("description") + << "'" + << std::endl; + } + } + } - return T (); + context.tdb.commit (); + context.tdb.unlock (); + + return out.str (); } //////////////////////////////////////////////////////////////////////////////// -int deltaAppend (T& task, T& delta) +int deltaAppend (Task& task) { - if (delta.getDescription () != "") + if (context.task.has ("description")) { - task.setDescription ( - task.getDescription () + - " " + - delta.getDescription ()); - + task.set ("description", + task.get ("description") + " " + context.task.get ("description")); return 1; } @@ -994,11 +1318,11 @@ int deltaAppend (T& task, T& delta) } //////////////////////////////////////////////////////////////////////////////// -int deltaDescription (T& task, T& delta) +int deltaDescription (Task& task) { - if (delta.getDescription () != "") + if (context.task.has ("description")) { - task.setDescription (delta.getDescription ()); + task.set ("description", context.task.get ("description")); return 1; } @@ -1006,31 +1330,22 @@ int deltaDescription (T& task, T& delta) } //////////////////////////////////////////////////////////////////////////////// -int deltaTags (T& task, T& delta) +int deltaTags (Task& task) { int changes = 0; // Apply or remove tags, if any. std::vector <std::string> tags; - delta.getTags (tags); - for (unsigned int i = 0; i < tags.size (); ++i) + context.task.getTags (tags); + foreach (tag, tags) { - if (tags[i][0] == '+') - task.addTag (tags[i].substr (1, std::string::npos)); - else - task.addTag (tags[i]); - + task.addTag (*tag); ++changes; } - delta.getRemoveTags (tags); - for (unsigned int i = 0; i < tags.size (); ++i) + foreach (tag, context.tagRemovals) { - if (tags[i][0] == '-') - task.removeTag (tags[i].substr (1, std::string::npos)); - else - task.removeTag (tags[i]); - + task.removeTag (*tag); ++changes; } @@ -1038,96 +1353,50 @@ int deltaTags (T& task, T& delta) } //////////////////////////////////////////////////////////////////////////////// -int deltaAttributes (T& task, T& delta) +int deltaAttributes (Task& task) { int changes = 0; - std::map <std::string, std::string> attributes; - delta.getAttributes (attributes); - foreach (i, attributes) + foreach (att, context.task) { - if (i->second == "") - task.removeAttribute (i->first); - else - task.setAttribute (i->first, i->second); + if (att->first != "uuid" && + att->first != "description" && + att->first != "tags") + { + // Modifying "wait" changes status. + if (att->first == "wait") + { + if (att->second.value () == "") + task.setStatus (Task::pending); + else + task.setStatus (Task::waiting); + } - ++changes; + if (att->second.value () == "") + task.remove (att->first); + else + task.set (att->first, att->second.value ()); + + ++changes; + } } return changes; } //////////////////////////////////////////////////////////////////////////////// -int deltaSubstitutions (T& task, T& delta) +int deltaSubstitutions (Task& task) { - int changes = 0; - std::string from; - std::string to; - bool global; - delta.getSubstitution (from, to, global); - - if (from != "") - { - std::string description = task.getDescription (); - size_t pattern; - - if (global) - { - // Perform all subs on description. - while ((pattern = description.find (from)) != std::string::npos) - { - description.replace (pattern, from.length (), to); - ++changes; - } - - task.setDescription (description); - - // Perform all subs on annotations. - std::map <time_t, std::string> annotations; - task.getAnnotations (annotations); - std::map <time_t, std::string>::iterator it; - for (it = annotations.begin (); it != annotations.end (); ++it) - { - while ((pattern = it->second.find (from)) != std::string::npos) - { - it->second.replace (pattern, from.length (), to); - ++changes; - } - } + std::string description = task.get ("description"); + std::vector <Att> annotations; + task.getAnnotations (annotations); - task.setAnnotations (annotations); - } - else - { - // Perform first description substitution. - if ((pattern = description.find (from)) != std::string::npos) - { - description.replace (pattern, from.length (), to); - task.setDescription (description); - ++changes; - } - // Failing that, perform the first annotation substitution. - else - { - std::map <time_t, std::string> annotations; - task.getAnnotations (annotations); + context.subst.apply (description, annotations); - std::map <time_t, std::string>::iterator it; - for (it = annotations.begin (); it != annotations.end (); ++it) - { - if ((pattern = it->second.find (from)) != std::string::npos) - { - it->second.replace (pattern, from.length (), to); - ++changes; - break; - } - } + task.set ("description", description); + task.setAnnotations (annotations); - task.setAnnotations (annotations); - } - } - } - return changes; + return 1; } //////////////////////////////////////////////////////////////////////////////// src/command.cpp @@ -33,7 +33,13 @@ #include <stdlib.h> #include <limits.h> #include <string.h> -#include "task.h" +#include "Date.h" +#include "Duration.h" +#include "text.h" +#include "util.h" +#include "main.h" + +extern Context context; //////////////////////////////////////////////////////////////////////////////// static std::string findValue ( @@ -59,7 +65,6 @@ static std::string findValue ( //////////////////////////////////////////////////////////////////////////////// static std::string findDate ( - Config& conf, const std::string& text, const std::string& name) { @@ -75,7 +80,7 @@ static std::string findDate ( if (value != "") { - Date dt (value, conf.get ("dateformat", "m/d/Y")); + Date dt (value, context.config.get ("dateformat", "m/d/Y")); char epoch [16]; sprintf (epoch, "%d", (int)dt.toEpoch ()); return std::string (epoch); @@ -87,37 +92,22 @@ static std::string findDate ( } //////////////////////////////////////////////////////////////////////////////// -static std::string formatStatus (T& task) -{ - switch (task.getStatus ()) - { - case T::pending: return "Pending"; break; - case T::completed: return "Completed"; break; - case T::deleted: return "Deleted"; break; - case T::recurring: return "Recurring"; break; - } - - return ""; -} - -//////////////////////////////////////////////////////////////////////////////// static std::string formatDate ( - Config& conf, - T& task, + Task& task, const std::string& attribute) { - std::string value = task.getAttribute (attribute); + std::string value = task.get (attribute); if (value.length ()) { Date dt (::atoi (value.c_str ())); - value = dt.toString (conf.get ("dateformat", "m/d/Y")); + value = dt.toString (context.config.get ("dateformat", "m/d/Y")); } return value; } //////////////////////////////////////////////////////////////////////////////// -static std::string formatTask (Config& conf, T task) +static std::string formatTask (Task task) { std::stringstream before; before << "# The 'task edit <id>' command allows you to modify all aspects of a task" << std::endl @@ -137,13 +127,13 @@ static std::string formatTask (Config& conf, T task) << "#" << std::endl << "# Name Editable details" << std::endl << "# ----------------- ----------------------------------------------------" << std::endl - << "# ID: " << task.getId () << std::endl - << "# UUID: " << task.getUUID () << std::endl - << "# Status: " << formatStatus (task) << std::endl - << "# Mask: " << task.getAttribute ("mask") << std::endl - << "# iMask: " << task.getAttribute ("imask") << std::endl - << " Project: " << task.getAttribute ("project") << std::endl - << " Priority: " << task.getAttribute ("priority") << std::endl; + << "# ID: " << task.id << std::endl + << "# UUID: " << task.get ("uuid") << std::endl + << "# Status: " << ucFirst (Task::statusToText (task.getStatus ())) << std::endl + << "# Mask: " << task.get ("mask") << std::endl + << "# iMask: " << task.get ("imask") << std::endl + << " Project: " << task.get ("project") << std::endl + << " Priority: " << task.get ("priority") << std::endl; std::vector <std::string> tags; task.getTags (tags); @@ -153,26 +143,27 @@ static std::string formatTask (Config& conf, T task) << " Tags: " << allTags << std::endl << "# The description field is allowed to wrap and use multiple lines. Task" << std::endl << "# will combine them." << std::endl - << " Description: " << task.getDescription () << std::endl - << " Created: " << formatDate (conf, task, "entry") << std::endl - << " Started: " << formatDate (conf, task, "start") << std::endl - << " Ended: " << formatDate (conf, task, "end") << std::endl - << " Due: " << formatDate (conf, task, "due") << std::endl - << " Until: " << formatDate (conf, task, "until") << std::endl - << " Recur: " << task.getAttribute ("recur") << std::endl - << " Parent: " << task.getAttribute ("parent") << std::endl - << " Foreground color: " << task.getAttribute ("fg") << std::endl - << " Background color: " << task.getAttribute ("bg") << std::endl + << " Description: " << task.get ("description") << std::endl + << " Created: " << formatDate (task, "entry") << std::endl + << " Started: " << formatDate (task, "start") << std::endl + << " Ended: " << formatDate (task, "end") << std::endl + << " Due: " << formatDate (task, "due") << std::endl + << " Until: " << formatDate (task, "until") << std::endl + << " Recur: " << task.get ("recur") << std::endl + << " Wait until: " << task.get ("wait") << std::endl + << " Parent: " << task.get ("parent") << std::endl + << " Foreground color: " << task.get ("fg") << std::endl + << " Background color: " << task.get ("bg") << std::endl << "# Annotations look like this: <date> <text>, and there can be any number" << std::endl << "# of them." << std::endl; - std::map <time_t, std::string> annotations; + std::vector <Att> annotations; task.getAnnotations (annotations); foreach (anno, annotations) { - Date dt (anno->first); - before << " Annotation: " << dt.toString (conf.get ("dateformat", "m/d/Y")) - << " " << anno->second << std::endl; + Date dt (::atoi (anno->name ().substr (11, std::string::npos).c_str ())); + before << " Annotation: " << dt.toString (context.config.get ("dateformat", "m/d/Y")) + << " " << anno->value () << std::endl; } before << " Annotation: " << std::endl @@ -182,40 +173,40 @@ static std::string formatTask (Config& conf, T task) } //////////////////////////////////////////////////////////////////////////////// -static void parseTask (Config& conf, T& task, const std::string& after) +static void parseTask (Task& task, const std::string& after) { // project std::string value = findValue (after, "Project:"); - if (task.getAttribute ("project") != value) + if (task.get ("project") != value) { if (value != "") { std::cout << "Project modified." << std::endl; - task.setAttribute ("project", value); + task.set ("project", value); } else { std::cout << "Project deleted." << std::endl; - task.removeAttribute ("project"); + task.remove ("project"); } } // priority value = findValue (after, "Priority:"); - if (task.getAttribute ("priority") != value) + if (task.get ("priority") != value) { if (value != "") { - if (validPriority (value)) + if (Att::validNameValue ("priority", "", value)) { std::cout << "Priority modified." << std::endl; - task.setAttribute ("priority", value); + task.set ("priority", value); } } else { std::cout << "Priority deleted." << std::endl; - task.removeAttribute ("priority"); + task.remove ("priority"); } } @@ -223,177 +214,178 @@ static void parseTask (Config& conf, T& task, const std::string& after) value = findValue (after, "Tags:"); std::vector <std::string> tags; split (tags, value, ' '); - task.removeTags (); + task.remove ("tags"); task.addTags (tags); // description. value = findValue (after, "Description: "); - if (task.getDescription () != value) + if (task.get ("description") != value) { if (value != "") { std::cout << "Description modified." << std::endl; - task.setDescription (value); + task.set ("description", value); } else throw std::string ("Cannot remove description."); } // entry - value = findDate (conf, after, "Created:"); + value = findDate (after, "Created:"); if (value != "") { Date edited (::atoi (value.c_str ())); - Date original (::atoi (task.getAttribute ("entry").c_str ())); + Date original (::atoi (task.get ("entry").c_str ())); if (!original.sameDay (edited)) { std::cout << "Creation date modified." << std::endl; - task.setAttribute ("entry", value); + task.set ("entry", value); } } else throw std::string ("Cannot remove creation date"); // start - value = findDate (conf, after, "Started:"); + value = findDate (after, "Started:"); if (value != "") { Date edited (::atoi (value.c_str ())); - if (task.getAttribute ("start") != "") + if (task.get ("start") != "") { - Date original (::atoi (task.getAttribute ("start").c_str ())); + Date original (::atoi (task.get ("start").c_str ())); if (!original.sameDay (edited)) { std::cout << "Start date modified." << std::endl; - task.setAttribute ("start", value); + task.set ("start", value); } } else { std::cout << "Start date modified." << std::endl; - task.setAttribute ("start", value); + task.set ("start", value); } } else { - if (task.getAttribute ("start") != "") + if (task.get ("start") != "") { std::cout << "Start date removed." << std::endl; - task.removeAttribute ("start"); + task.remove ("start"); } } // end - value = findDate (conf, after, "Ended:"); + value = findDate (after, "Ended:"); if (value != "") { Date edited (::atoi (value.c_str ())); - if (task.getAttribute ("end") != "") + if (task.get ("end") != "") { - Date original (::atoi (task.getAttribute ("end").c_str ())); + Date original (::atoi (task.get ("end").c_str ())); if (!original.sameDay (edited)) { std::cout << "Done date modified." << std::endl; - task.setAttribute ("end", value); + task.set ("end", value); } } - else if (task.getStatus () != T::deleted) + else if (task.getStatus () != Task::deleted) throw std::string ("Cannot set a done date on a pending task."); } else { - if (task.getAttribute ("end") != "") + if (task.get ("end") != "") { std::cout << "Done date removed." << std::endl; - task.setStatus (T::pending); - task.removeAttribute ("end"); + task.setStatus (Task::pending); + task.remove ("end"); } } // due - value = findDate (conf, after, "Due:"); + value = findDate (after, "Due:"); if (value != "") { Date edited (::atoi (value.c_str ())); - if (task.getAttribute ("due") != "") + if (task.get ("due") != "") { - Date original (::atoi (task.getAttribute ("due").c_str ())); + Date original (::atoi (task.get ("due").c_str ())); if (!original.sameDay (edited)) { std::cout << "Due date modified." << std::endl; - task.setAttribute ("due", value); + task.set ("due", value); } } else { std::cout << "Due date modified." << std::endl; - task.setAttribute ("due", value); + task.set ("due", value); } } else { - if (task.getAttribute ("due") != "") + if (task.get ("due") != "") { - if (task.getStatus () == T::recurring || - task.getAttribute ("parent") != "") + if (task.getStatus () == Task::recurring || + task.get ("parent") != "") { std::cout << "Cannot remove a due date from a recurring task." << std::endl; } else { std::cout << "Due date removed." << std::endl; - task.removeAttribute ("due"); + task.remove ("due"); } } } // until - value = findDate (conf, after, "Until:"); + value = findDate (after, "Until:"); if (value != "") { Date edited (::atoi (value.c_str ())); - if (task.getAttribute ("until") != "") + if (task.get ("until") != "") { - Date original (::atoi (task.getAttribute ("until").c_str ())); + Date original (::atoi (task.get ("until").c_str ())); if (!original.sameDay (edited)) { std::cout << "Until date modified." << std::endl; - task.setAttribute ("until", value); + task.set ("until", value); } } else { std::cout << "Until date modified." << std::endl; - task.setAttribute ("until", value); + task.set ("until", value); } } else { - if (task.getAttribute ("until") != "") + if (task.get ("until") != "") { std::cout << "Until date removed." << std::endl; - task.removeAttribute ("until"); + task.remove ("until"); } } // recur value = findValue (after, "Recur:"); - if (value != task.getAttribute ("recur")) + if (value != task.get ("recur")) { if (value != "") { - if (validDuration (value)) + Duration d; + if (d.valid (value)) { std::cout << "Recurrence modified." << std::endl; - if (task.getAttribute ("due") != "") + if (task.get ("due") != "") { - task.setAttribute ("recur", value); - task.setStatus (T::recurring); + task.set ("recur", value); + task.setStatus (Task::recurring); } else throw std::string ("A recurring task must have a due date."); @@ -404,64 +396,94 @@ static void parseTask (Config& conf, T& task, const std::string& after) else { std::cout << "Recurrence removed." << std::endl; - task.setStatus (T::pending); - task.removeAttribute ("recur"); - task.removeAttribute ("until"); - task.removeAttribute ("mask"); - task.removeAttribute ("imask"); + task.setStatus (Task::pending); + task.remove ("recur"); + task.remove ("until"); + task.remove ("mask"); + task.remove ("imask"); + } + } + + // wait + value = findDate (after, "Wait until:"); + if (value != "") + { + Date edited (::atoi (value.c_str ())); + + if (task.get ("wait") != "") + { + Date original (::atoi (task.get ("wait").c_str ())); + if (!original.sameDay (edited)) + { + std::cout << "Wait date modified." << std::endl; + task.set ("wait", value); + } + } + else + { + std::cout << "Wait date modified." << std::endl; + task.set ("wait", value); + } + } + else + { + if (task.get ("wait") != "") + { + std::cout << "Wait date removed." << std::endl; + task.remove ("wait"); } } // parent value = findValue (after, "Parent:"); - if (value != task.getAttribute ("parent")) + if (value != task.get ("parent")) { if (value != "") { std::cout << "Parent UUID modified." << std::endl; - task.setAttribute ("parent", value); + task.set ("parent", value); } else { std::cout << "Parent UUID removed." << std::endl; - task.removeAttribute ("parent"); + task.remove ("parent"); } } // fg value = findValue (after, "Foreground color:"); - if (value != task.getAttribute ("fg")) + if (value != task.get ("fg")) { if (value != "") { std::cout << "Foreground color modified." << std::endl; - task.setAttribute ("fg", value); + task.set ("fg", value); } else { std::cout << "Foreground color removed." << std::endl; - task.removeAttribute ("fg"); + task.remove ("fg"); } } // bg value = findValue (after, "Background color:"); - if (value != task.getAttribute ("bg")) + if (value != task.get ("bg")) { if (value != "") { std::cout << "Background color modified." << std::endl; - task.setAttribute ("bg", value); + task.set ("bg", value); } else { std::cout << "Background color removed." << std::endl; - task.removeAttribute ("bg"); + task.remove ("bg"); } } // Annotations - std::map <time_t, std::string> annotations; + std::vector <Att> annotations; std::string::size_type found = 0; while ((found = after.find ("Annotation:", found)) != std::string::npos) { @@ -478,8 +500,10 @@ static void parseTask (Config& conf, T& task, const std::string& after) if (gap != std::string::npos) { Date when (value.substr (0, gap)); + std::stringstream name; + name << "annotation_" << when.toEpoch (); std::string text = trim (value.substr (gap, std::string::npos), "\t "); - annotations[when.toEpoch ()] = text; + annotations.push_back (Att (name.str (), text)); } } } @@ -488,100 +512,131 @@ static void parseTask (Config& conf, T& task, const std::string& after) } //////////////////////////////////////////////////////////////////////////////// -// Introducing the Silver Bullet. This feature is the catch-all fixative for -// various other ills. This is like opening up the hood and going in with a -// wrench. To be used sparingly. -std::string handleEdit (TDB& tdb, T& task, Config& conf) +void editFile (Task& task) { - std::stringstream out; - std::vector <T> all; - tdb.allPendingT (all); - - filterSequence (all, task); - foreach (seq, all) - { - // Check for file permissions. - std::string dataLocation = expandPath (conf.get ("data.location")); - if (access (dataLocation.c_str (), X_OK)) - throw std::string ("Your data.location directory is not writable."); - - // Create a temp file name in data.location. - std::stringstream pattern; - pattern << dataLocation << "/task." << seq->getId () << ".XXXXXX"; - char cpattern [PATH_MAX]; - strcpy (cpattern, pattern.str ().c_str ()); - mkstemp (cpattern); - char* file = cpattern; - - // Format the contents, T -> text, write to a file. - std::string before = formatTask (conf, *seq); - spit (file, before); - - // Determine correct editor: .taskrc:editor > $VISUAL > $EDITOR > vi - std::string editor = conf.get ("editor", ""); - char* peditor = getenv ("VISUAL"); - if (editor == "" && peditor) editor = std::string (peditor); - peditor = getenv ("EDITOR"); - if (editor == "" && peditor) editor = std::string (peditor); - if (editor == "") editor = "vi"; - - // Complete the command line. - editor += " "; - editor += file; + // Check for file permissions. + std::string dataLocation = expandPath (context.config.get ("data.location")); + if (access (dataLocation.c_str (), X_OK)) + throw std::string ("Your data.location directory is not writable."); + + // Create a temp file name in data.location. + std::stringstream file; + file << dataLocation << "/task." << getpid () << "." << task.id << ".task"; + + // Format the contents, T -> text, write to a file. + std::string before = formatTask (task); + spit (file.str (), before); + + // Determine correct editor: .taskrc:editor > $VISUAL > $EDITOR > vi + std::string editor = context.config.get ("editor", ""); + char* peditor = getenv ("VISUAL"); + if (editor == "" && peditor) editor = std::string (peditor); + peditor = getenv ("EDITOR"); + if (editor == "" && peditor) editor = std::string (peditor); + if (editor == "") editor = "vi"; + + // Complete the command line. + editor += " "; + editor += file.str (); ARE_THESE_REALLY_HARMFUL: - // Launch the editor. - std::cout << "Launching '" << editor << "' now..." << std::endl; - system (editor.c_str ()); + // Launch the editor. + std::cout << "Launching '" << editor << "' now..." << std::endl; + if (-1 == system (editor.c_str ())) + std::cout << "No editing performed." << std::endl; + else std::cout << "Editing complete." << std::endl; - // Slurp file. - std::string after; - slurp (file, after, false); + // Slurp file. + std::string after; + slurp (file.str (), after, false); - // TODO Remove this debugging code. - //spit ("./before", before); - //spit ("./after", after); + // Update task based on what can be parsed back out of the file, but only + // if changes were made. + if (before != after) + { + std::cout << "Edits were detected." << std::endl; + std::string problem = ""; + bool oops = false; - // Update seq based on what can be parsed back out of the file, but only - // if changes were made. - if (before != after) + try { - std::cout << "Edits were detected." << std::endl; - std::string problem = ""; - bool oops = false; + parseTask (task, after); + } - try - { - parseTask (conf, *seq, after); - tdb.modifyT (*seq); - } + catch (std::string& e) + { + problem = e; + oops = true; + } - catch (std::string& e) - { - problem = e; - oops = true; - } + if (oops) + { + std::cout << "Error: " << problem << std::endl; - if (oops) - { - std::cout << "Error: " << problem << std::endl; + // Preserve the edits. + before = after; + spit (file.str (), before); - // Preserve the edits. - before = after; - spit (file, before); + if (confirm ("Task couldn't handle your edits. Would you like to try again?")) + goto ARE_THESE_REALLY_HARMFUL; + } + } + else + std::cout << "No edits were detected." << std::endl; + + // Cleanup. + unlink (file.str ().c_str ()); +} - if (confirm ("Task couldn't handle your edits. Would you like to try again?")) - goto ARE_THESE_REALLY_HARMFUL; +//////////////////////////////////////////////////////////////////////////////// +// Introducing the Silver Bullet. This feature is the catch-all fixative for +// various other ills. This is like opening up the hood and going in with a +// wrench. To be used sparingly. +std::string handleEdit () +{ + std::stringstream out; + + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + Filter filter; + context.tdb.loadPending (tasks, filter); + + // Filter sequence. + std::vector <Task> all = tasks; + context.filter.applySequence (tasks, context.sequence); + + foreach (task, tasks) + { + editFile (*task); + context.tdb.update (*task); +/* + foreach (other, all) + { + if (other->id != task.id) // Don't edit the same task again. + { + if (task.has ("parent") && + if (other is parent of task) + { + // Transfer everything but mask, imask, uuid, parent. + } + else if (task is parent of other) + { + // Transfer everything but mask, imask, uuid, parent. + } + else if (task and other are siblings) + { + // Transfer everything but mask, imask, uuid, parent. + } } } - else - std::cout << "No edits were detected." << std::endl; - - // Cleanup. - unlink (file); +*/ } + context.tdb.commit (); + context.tdb.unlock (); + return out.str (); } src/edit.cpp @@ -29,7 +29,11 @@ #include <stdio.h> #include <unistd.h> #include "Date.h" -#include "task.h" +#include "text.h" +#include "util.h" +#include "main.h" + +extern Context context; //////////////////////////////////////////////////////////////////////////////// enum fileType @@ -155,33 +159,34 @@ static fileType determineFileType (const std::vector <std::string>& lines) } //////////////////////////////////////////////////////////////////////////////// -static void decorateTask (T& task, Config& conf) +static void decorateTask (Task& task) { char entryTime[16]; sprintf (entryTime, "%u", (unsigned int) time (NULL)); - task.setAttribute ("entry", entryTime); + task.set ("entry", entryTime); + + task.setStatus (Task::pending); // Override with default.project, if not specified. - std::string defaultProject = conf.get ("default.project", ""); - if (task.getAttribute ("project") == "" && defaultProject != "") - task.setAttribute ("project", defaultProject); + std::string defaultProject = context.config.get ("default.project", ""); + if (!task.has ("project") && defaultProject != "") + task.set ("project", defaultProject); // Override with default.priority, if not specified. - std::string defaultPriority = conf.get ("default.priority", ""); - if (task.getAttribute ("priority") == "" && - defaultPriority != "" && - validPriority (defaultPriority)) - task.setAttribute ("priority", defaultPriority); + std::string defaultPriority = context.config.get ("default.priority", ""); + if (!task.has ("priority") && + defaultPriority != "" && + Att::validNameValue ("priority", "", defaultPriority)) + task.set ("priority", defaultPriority); } //////////////////////////////////////////////////////////////////////////////// -static std::string importTask_1_4_3 ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importTask_1_4_3 (const std::vector <std::string>& lines) { std::vector <std::string> failed; + context.tdb.lock (context.config.get ("locking", true)); + std::vector <std::string>::const_iterator it; for (it = lines.begin (); it != lines.end (); ++it) { @@ -227,7 +232,7 @@ static std::string importTask_1_4_3 ( throw "unrecoverable"; // Build up this task ready for insertion. - T task; + Task task; // Handle the 12 fields. for (unsigned int f = 0; f < fields.size (); ++f) @@ -235,14 +240,14 @@ static std::string importTask_1_4_3 ( switch (f) { case 0: // 'uuid' - task.setUUID (fields[f].substr (1, 36)); + task.set ("uuid", fields[f].substr (1, 36)); break; case 1: // 'status' - if (fields[f] == "'pending'") task.setStatus (T::pending); - else if (fields[f] == "'recurring'") task.setStatus (T::recurring); - else if (fields[f] == "'deleted'") task.setStatus (T::deleted); - else if (fields[f] == "'completed'") task.setStatus (T::completed); + if (fields[f] == "'pending'") task.setStatus (Task::pending); + else if (fields[f] == "'recurring'") task.setStatus (Task::recurring); + else if (fields[f] == "'deleted'") task.setStatus (Task::deleted); + else if (fields[f] == "'completed'") task.setStatus (Task::completed); break; case 2: // 'tags' @@ -257,53 +262,52 @@ static std::string importTask_1_4_3 ( break; case 3: // entry - task.setAttribute ("entry", fields[f]); + task.set ("entry", fields[f]); break; case 4: // start if (fields[f].length ()) - task.setAttribute ("start", fields[f]); + task.set ("start", fields[f]); break; case 5: // due if (fields[f].length ()) - task.setAttribute ("due", fields[f]); + task.set ("due", fields[f]); break; case 6: // end if (fields[f].length ()) - task.setAttribute ("end", fields[f]); + task.set ("end", fields[f]); break; case 7: // 'project' if (fields[f].length () > 2) - task.setAttribute ("project", fields[f].substr (1, fields[f].length () - 2)); + task.set ("project", fields[f].substr (1, fields[f].length () - 2)); break; case 8: // 'priority' if (fields[f].length () > 2) - task.setAttribute ("priority", fields[f].substr (1, fields[f].length () - 2)); + task.set ("priority", fields[f].substr (1, fields[f].length () - 2)); break; case 9: // 'fg' if (fields[f].length () > 2) - task.setAttribute ("fg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("fg", fields[f].substr (1, fields[f].length () - 2)); break; case 10: // 'bg' if (fields[f].length () > 2) - task.setAttribute ("bg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("bg", fields[f].substr (1, fields[f].length () - 2)); break; case 11: // 'description' if (fields[f].length () > 2) - task.setDescription (fields[f].substr (1, fields[f].length () - 2)); + task.set ("description", fields[f].substr (1, fields[f].length () - 2)); break; } } - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (task); } catch (...) @@ -312,6 +316,9 @@ static std::string importTask_1_4_3 ( } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << (lines.size () - failed.size () - 1) @@ -331,13 +338,12 @@ static std::string importTask_1_4_3 ( } //////////////////////////////////////////////////////////////////////////////// -static std::string importTask_1_5_0 ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importTask_1_5_0 (const std::vector <std::string>& lines) { std::vector <std::string> failed; + context.tdb.lock (context.config.get ("locking", true)); + std::vector <std::string>::const_iterator it; for (it = lines.begin (); it != lines.end (); ++it) { @@ -383,7 +389,7 @@ static std::string importTask_1_5_0 ( throw "unrecoverable"; // Build up this task ready for insertion. - T task; + Task task; // Handle the 13 fields. for (unsigned int f = 0; f < fields.size (); ++f) @@ -391,14 +397,14 @@ static std::string importTask_1_5_0 ( switch (f) { case 0: // 'uuid' - task.setUUID (fields[f].substr (1, 36)); + task.set ("uuid", fields[f].substr (1, 36)); break; case 1: // 'status' - if (fields[f] == "'pending'") task.setStatus (T::pending); - else if (fields[f] == "'recurring'") task.setStatus (T::recurring); - else if (fields[f] == "'deleted'") task.setStatus (T::deleted); - else if (fields[f] == "'completed'") task.setStatus (T::completed); + if (fields[f] == "'pending'") task.setStatus (Task::pending); + else if (fields[f] == "'recurring'") task.setStatus (Task::recurring); + else if (fields[f] == "'deleted'") task.setStatus (Task::deleted); + else if (fields[f] == "'completed'") task.setStatus (Task::completed); break; case 2: // 'tags' @@ -413,58 +419,57 @@ static std::string importTask_1_5_0 ( break; case 3: // entry - task.setAttribute ("entry", fields[f]); + task.set ("entry", fields[f]); break; case 4: // start if (fields[f].length ()) - task.setAttribute ("start", fields[f]); + task.set ("start", fields[f]); break; case 5: // due if (fields[f].length ()) - task.setAttribute ("due", fields[f]); + task.set ("due", fields[f]); break; case 6: // recur if (fields[f].length ()) - task.setAttribute ("recur", fields[f]); + task.set ("recur", fields[f]); break; case 7: // end if (fields[f].length ()) - task.setAttribute ("end", fields[f]); + task.set ("end", fields[f]); break; case 8: // 'project' if (fields[f].length () > 2) - task.setAttribute ("project", fields[f].substr (1, fields[f].length () - 2)); + task.set ("project", fields[f].substr (1, fields[f].length () - 2)); break; case 9: // 'priority' if (fields[f].length () > 2) - task.setAttribute ("priority", fields[f].substr (1, fields[f].length () - 2)); + task.set ("priority", fields[f].substr (1, fields[f].length () - 2)); break; case 10: // 'fg' if (fields[f].length () > 2) - task.setAttribute ("fg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("fg", fields[f].substr (1, fields[f].length () - 2)); break; case 11: // 'bg' if (fields[f].length () > 2) - task.setAttribute ("bg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("bg", fields[f].substr (1, fields[f].length () - 2)); break; case 12: // 'description' if (fields[f].length () > 2) - task.setDescription (fields[f].substr (1, fields[f].length () - 2)); + task.set ("description", fields[f].substr (1, fields[f].length () - 2)); break; } } - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (task); } catch (...) @@ -473,6 +478,9 @@ static std::string importTask_1_5_0 ( } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << (lines.size () - failed.size () - 1) @@ -492,13 +500,12 @@ static std::string importTask_1_5_0 ( } //////////////////////////////////////////////////////////////////////////////// -static std::string importTask_1_6_0 ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importTask_1_6_0 (const std::vector <std::string>& lines) { std::vector <std::string> failed; + context.tdb.lock (context.config.get ("locking", true)); + std::vector <std::string>::const_iterator it; for (it = lines.begin (); it != lines.end (); ++it) { @@ -544,7 +551,7 @@ static std::string importTask_1_6_0 ( throw "unrecoverable"; // Build up this task ready for insertion. - T task; + Task task; // Handle the 13 fields. for (unsigned int f = 0; f < fields.size (); ++f) @@ -552,14 +559,15 @@ static std::string importTask_1_6_0 ( switch (f) { case 0: // 'uuid' - task.setUUID (fields[f].substr (1, 36)); + task.set ("uuid", fields[f].substr (1, 36)); break; case 1: // 'status' - if (fields[f] == "'pending'") task.setStatus (T::pending); - else if (fields[f] == "'recurring'") task.setStatus (T::recurring); - else if (fields[f] == "'deleted'") task.setStatus (T::deleted); - else if (fields[f] == "'completed'") task.setStatus (T::completed); + if (fields[f] == "'pending'") task.setStatus (Task::pending); + else if (fields[f] == "'recurring'") task.setStatus (Task::recurring); + else if (fields[f] == "'deleted'") task.setStatus (Task::deleted); + else if (fields[f] == "'completed'") task.setStatus (Task::completed); + else if (fields[f] == "'waiting'") task.setStatus (Task::waiting); break; case 2: // 'tags' @@ -574,58 +582,57 @@ static std::string importTask_1_6_0 ( break; case 3: // entry - task.setAttribute ("entry", fields[f]); + task.set ("entry", fields[f]); break; case 4: // start if (fields[f].length ()) - task.setAttribute ("start", fields[f]); + task.set ("start", fields[f]); break; case 5: // due if (fields[f].length ()) - task.setAttribute ("due", fields[f]); + task.set ("due", fields[f]); break; case 6: // recur if (fields[f].length ()) - task.setAttribute ("recur", fields[f]); + task.set ("recur", fields[f]); break; case 7: // end if (fields[f].length ()) - task.setAttribute ("end", fields[f]); + task.set ("end", fields[f]); break; case 8: // 'project' if (fields[f].length () > 2) - task.setAttribute ("project", fields[f].substr (1, fields[f].length () - 2)); + task.set ("project", fields[f].substr (1, fields[f].length () - 2)); break; case 9: // 'priority' if (fields[f].length () > 2) - task.setAttribute ("priority", fields[f].substr (1, fields[f].length () - 2)); + task.set ("priority", fields[f].substr (1, fields[f].length () - 2)); break; case 10: // 'fg' if (fields[f].length () > 2) - task.setAttribute ("fg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("fg", fields[f].substr (1, fields[f].length () - 2)); break; case 11: // 'bg' if (fields[f].length () > 2) - task.setAttribute ("bg", fields[f].substr (1, fields[f].length () - 2)); + task.set ("bg", fields[f].substr (1, fields[f].length () - 2)); break; case 12: // 'description' if (fields[f].length () > 2) - task.setDescription (fields[f].substr (1, fields[f].length () - 2)); + task.set ("description", fields[f].substr (1, fields[f].length () - 2)); break; } } - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (task); } catch (...) @@ -634,6 +641,9 @@ static std::string importTask_1_6_0 ( } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << (lines.size () - failed.size () - 1) @@ -653,10 +663,7 @@ static std::string importTask_1_6_0 ( } //////////////////////////////////////////////////////////////////////////////// -static std::string importTaskCmdLine ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importTaskCmdLine (const std::vector <std::string>& lines) { std::vector <std::string> failed; @@ -667,17 +674,19 @@ static std::string importTaskCmdLine ( try { - std::vector <std::string> args; - split (args, std::string ("add ") + line, ' '); - - T task; - std::string command; - parse (args, command, task, conf); - handleAdd (tdb, task, conf); + context.args.clear (); + split (context.args, std::string ("add ") + line, ' '); + + context.task.clear (); + context.cmd.command = ""; + context.parse (); + handleAdd (); + context.clearMessages (); } catch (...) { + context.clearMessages (); failed.push_back (line); } } @@ -701,20 +710,19 @@ static std::string importTaskCmdLine ( } //////////////////////////////////////////////////////////////////////////////// -static std::string importTodoSh_2_0 ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importTodoSh_2_0 (const std::vector <std::string>& lines) { std::vector <std::string> failed; + context.tdb.lock (context.config.get ("locking", true)); + std::vector <std::string>::const_iterator it; for (it = lines.begin (); it != lines.end (); ++it) { try { - std::vector <std::string> args; - args.push_back ("add"); + context.args.clear (); + context.args.push_back ("add"); bool isPending = true; Date endDate; @@ -727,8 +735,8 @@ static std::string importTodoSh_2_0 ( if (words[w].length () > 1 && words[w][0] == '+') { - args.push_back (std::string ("project:") + - words[w].substr (1, std::string::npos)); + context.args.push_back (std::string ("project:") + + words[w].substr (1, std::string::npos)); } // Convert "+aaa" to "project:aaa". @@ -736,8 +744,8 @@ static std::string importTodoSh_2_0 ( else if (words[w].length () > 1 && words[w][0] == '@') { - args.push_back (std::string ("+") + - words[w].substr (1, std::string::npos)); + context.args.push_back (std::string ("+") + + words[w].substr (1, std::string::npos)); } // Convert "(A)" to "priority:H". @@ -747,9 +755,9 @@ static std::string importTodoSh_2_0 ( words[w][0] == '(' && words[w][2] == ')') { - if (words[w][1] == 'A') args.push_back ("priority:H"); - else if (words[w][1] == 'B') args.push_back ("priority:M"); - else args.push_back ("priority:L"); + if (words[w][1] == 'A') context.args.push_back ("priority:H"); + else if (words[w][1] == 'B') context.args.push_back ("priority:M"); + else context.args.push_back ("priority:L"); } // Set status, if completed. @@ -772,38 +780,42 @@ static std::string importTodoSh_2_0 ( // Just an ordinary word. else { - args.push_back (words[w]); + context.args.push_back (words[w]); } } - T task; - std::string command; - parse (args, command, task, conf); - decorateTask (task, conf); + context.task.clear (); + context.cmd.command = ""; + context.parse (); + decorateTask (context.task); if (isPending) { - task.setStatus (T::pending); + context.task.setStatus (Task::pending); } else { - task.setStatus (T::completed); + context.task.setStatus (Task::completed); char end[16]; sprintf (end, "%u", (unsigned int) endDate.toEpoch ()); - task.setAttribute ("end", end); + context.task.set ("end", end); } - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (context.task); + context.clearMessages (); } catch (...) { + context.clearMessages (); failed.push_back (*it); } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << (lines.size () - failed.size ()) @@ -818,19 +830,17 @@ static std::string importTodoSh_2_0 ( join (bad, "\n", failed); return out.str () + "\nCould not import:\n\n" + bad; } - return out.str (); } //////////////////////////////////////////////////////////////////////////////// -static std::string importText ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importText (const std::vector <std::string>& lines) { std::vector <std::string> failed; int count = 0; + context.tdb.lock (context.config.get ("locking", true)); + std::vector <std::string>::const_iterator it; for (it = lines.begin (); it != lines.end (); ++it) { @@ -847,25 +857,29 @@ static std::string importText ( try { ++count; - std::vector <std::string> args; - split (args, std::string ("add ") + line, ' '); + context.args.clear (); + split (context.args, std::string ("add ") + line, ' '); - T task; - std::string command; - parse (args, command, task, conf); - decorateTask (task, conf); + context.task.clear (); + context.cmd.command = ""; + context.parse (); + decorateTask (context.task); - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (context.task); + context.clearMessages (); } catch (...) { + context.clearMessages (); failed.push_back (line); } } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << count @@ -885,13 +899,12 @@ static std::string importText ( } //////////////////////////////////////////////////////////////////////////////// -static std::string importCSV ( - TDB& tdb, - Config& conf, - const std::vector <std::string>& lines) +static std::string importCSV (const std::vector <std::string>& lines) { std::vector <std::string> failed; + context.tdb.lock (context.config.get ("locking", true)); + // Set up mappings. Assume no fields match. std::map <std::string, int> mapping; mapping ["id"] = -1; @@ -917,7 +930,7 @@ static std::string importCSV ( std::string name = lowerCase (trim (unquoteText (trim (headings[h])))); // If there is a mapping for the field, use the value. - if (name == conf.get ("import.synonym.id") || + if (name == context.config.get ("import.synonym.id") || name == "id" || name == "#" || name == "sequence" || @@ -926,7 +939,7 @@ static std::string importCSV ( mapping["id"] = (int)h; } - else if (name == conf.get ("import.synonym.uuid") || + else if (name == context.config.get ("import.synonym.uuid") || name == "uuid" || name == "guid" || name.find ("unique") != std::string::npos) @@ -934,7 +947,7 @@ static std::string importCSV ( mapping["uuid"] = (int)h; } - else if (name == conf.get ("import.synonym.status") || + else if (name == context.config.get ("import.synonym.status") || name == "status" || name == "condition" || name == "state") @@ -942,7 +955,7 @@ static std::string importCSV ( mapping["status"] = (int)h; } - else if (name == conf.get ("import.synonym.tags") || + else if (name == context.config.get ("import.synonym.tags") || name == "tags" || name.find ("categor") != std::string::npos || name.find ("tag") != std::string::npos) @@ -950,7 +963,7 @@ static std::string importCSV ( mapping["tags"] = (int)h; } - else if (name == conf.get ("import.synonym.entry") || + else if (name == context.config.get ("import.synonym.entry") || name == "entry" || name.find ("added") != std::string::npos || name.find ("created") != std::string::npos || @@ -959,7 +972,7 @@ static std::string importCSV ( mapping["entry"] = (int)h; } - else if (name == conf.get ("import.synonym.start") || + else if (name == context.config.get ("import.synonym.start") || name == "start" || name.find ("began") != std::string::npos || name.find ("begun") != std::string::npos || @@ -968,21 +981,21 @@ static std::string importCSV ( mapping["start"] = (int)h; } - else if (name == conf.get ("import.synonym.due") || + else if (name == context.config.get ("import.synonym.due") || name == "due" || name.find ("expected") != std::string::npos) { mapping["due"] = (int)h; } - else if (name == conf.get ("import.synonym.recur") || + else if (name == context.config.get ("import.synonym.recur") || name == "recur" || name == "frequency") { mapping["recur"] = (int)h; } - else if (name == conf.get ("import.synonym.end") || + else if (name == context.config.get ("import.synonym.end") || name == "end" || name == "done" || name.find ("complete") != std::string::npos) @@ -990,14 +1003,14 @@ static std::string importCSV ( mapping["end"] = (int)h; } - else if (name == conf.get ("import.synonym.project") || + else if (name == context.config.get ("import.synonym.project") || name == "project" || name.find ("proj") != std::string::npos) { mapping["project"] = (int)h; } - else if (name == conf.get ("import.synonym.priority") || + else if (name == context.config.get ("import.synonym.priority") || name == "priority" || name == "pri" || name.find ("importan") != std::string::npos) @@ -1005,7 +1018,7 @@ static std::string importCSV ( mapping["priority"] = (int)h; } - else if (name == conf.get ("import.synonym.fg") || + else if (name == context.config.get ("import.synonym.fg") || name.find ("fg") != std::string::npos || name.find ("foreground") != std::string::npos || name.find ("color") != std::string::npos) @@ -1013,14 +1026,14 @@ static std::string importCSV ( mapping["fg"] = (int)h; } - else if (name == conf.get ("import.synonym.bg") || + else if (name == context.config.get ("import.synonym.bg") || name == "bg" || name.find ("background") != std::string::npos) { mapping["bg"] = (int)h; } - else if (name == conf.get ("import.synonym.description") || + else if (name == context.config.get ("import.synonym.description") || name.find ("desc") != std::string::npos || name.find ("detail") != std::string::npos || name.find ("task") != std::string::npos || @@ -1040,20 +1053,21 @@ static std::string importCSV ( std::vector <std::string> fields; split (fields, *it, ','); - T task; + Task task; int f; if ((f = mapping["uuid"]) != -1) - task.setUUID (lowerCase (unquoteText (trim (fields[f])))); + task.set ("uuid", lowerCase (unquoteText (trim (fields[f])))); + task.setStatus (Task::pending); if ((f = mapping["status"]) != -1) { std::string value = lowerCase (unquoteText (trim (fields[f]))); - if (value == "recurring") task.setStatus (T::recurring); - else if (value == "deleted") task.setStatus (T::deleted); - else if (value == "completed") task.setStatus (T::completed); - else task.setStatus (T::pending); + if (value == "recurring") task.setStatus (Task::recurring); + else if (value == "deleted") task.setStatus (Task::deleted); + else if (value == "completed") task.setStatus (Task::completed); + else if (value == "waiting") task.setStatus (Task::waiting); } if ((f = mapping["tags"]) != -1) @@ -1066,41 +1080,40 @@ static std::string importCSV ( } if ((f = mapping["entry"]) != -1) - task.setAttribute ("entry", lowerCase (unquoteText (trim (fields[f])))); + task.set ("entry", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["start"]) != -1) - task.setAttribute ("start", lowerCase (unquoteText (trim (fields[f])))); + task.set ("start", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["due"]) != -1) - task.setAttribute ("due", lowerCase (unquoteText (trim (fields[f])))); + task.set ("due", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["recur"]) != -1) - task.setAttribute ("recur", lowerCase (unquoteText (trim (fields[f])))); + task.set ("recur", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["end"]) != -1) - task.setAttribute ("end", lowerCase (unquoteText (trim (fields[f])))); + task.set ("end", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["project"]) != -1) - task.setAttribute ("project", unquoteText (trim (fields[f]))); + task.set ("project", unquoteText (trim (fields[f]))); if ((f = mapping["priority"]) != -1) { std::string value = upperCase (unquoteText (trim (fields[f]))); if (value == "H" || value == "M" || value == "L") - task.setAttribute ("priority", value); + task.set ("priority", value); } if ((f = mapping["fg"]) != -1) - task.setAttribute ("fg", lowerCase (unquoteText (trim (fields[f])))); + task.set ("fg", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["bg"]) != -1) - task.setAttribute ("bg", lowerCase (unquoteText (trim (fields[f])))); + task.set ("bg", lowerCase (unquoteText (trim (fields[f])))); if ((f = mapping["description"]) != -1) - task.setDescription (unquoteText (trim (fields[f]))); + task.set ("description", unquoteText (trim (fields[f]))); - if (! tdb.addT (task)) - failed.push_back (*it); + context.tdb.add (task); } catch (...) @@ -1109,6 +1122,9 @@ static std::string importCSV ( } } + context.tdb.commit (); + context.tdb.unlock (); + std::stringstream out; out << "Imported " << (lines.size () - failed.size () - 1) @@ -1128,12 +1144,12 @@ static std::string importCSV ( } //////////////////////////////////////////////////////////////////////////////// -std::string handleImport (TDB& tdb, T& task, Config& conf) +std::string handleImport () { std::stringstream out; // Use the description as a file name. - std::string file = trim (task.getDescription ()); + std::string file = trim (context.task.get ("description")); if (file.length () > 0) { // Load the file. @@ -1169,7 +1185,7 @@ std::string handleImport (TDB& tdb, T& task, Config& conf) case task_cmd_line: identifier = "This looks like task command line arguments."; break; case todo_sh_2_0: identifier = "This looks like a todo.sh 2.x file."; break; case csv: identifier = "This looks like a CSV file, but not a task export file."; break; - case text: identifier = "This looks like a text file with one tasks per line."; break; + case text: identifier = "This looks like a text file with one task per line."; break; case not_a_clue: throw std::string ("Task cannot determine which type of file this is, " "and cannot proceed."); @@ -1183,13 +1199,13 @@ std::string handleImport (TDB& tdb, T& task, Config& conf) // Determine which type it might be, then attempt an import. switch (type) { - case task_1_4_3: out << importTask_1_4_3 (tdb, conf, lines); break; - case task_1_5_0: out << importTask_1_5_0 (tdb, conf, lines); break; - case task_1_6_0: out << importTask_1_6_0 (tdb, conf, lines); break; - case task_cmd_line: out << importTaskCmdLine (tdb, conf, lines); break; - case todo_sh_2_0: out << importTodoSh_2_0 (tdb, conf, lines); break; - case csv: out << importCSV (tdb, conf, lines); break; - case text: out << importText (tdb, conf, lines); break; + case task_1_4_3: out << importTask_1_4_3 (lines); break; + case task_1_5_0: out << importTask_1_5_0 (lines); break; + case task_1_6_0: out << importTask_1_6_0 (lines); break; + case task_cmd_line: out << importTaskCmdLine (lines); break; + case todo_sh_2_0: out << importTodoSh_2_0 (lines); break; + case csv: out << importCSV (lines); break; + case text: out << importText (lines); break; case not_a_clue: /* to stop the compiler from complaining. */ break; } } @@ -1200,4 +1216,3 @@ std::string handleImport (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// - src/import.cpp @@ -29,508 +29,475 @@ #include <sstream> #include <fstream> #include <sys/types.h> +#include <sys/stat.h> #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <pwd.h> #include <time.h> -#include "Config.h" +#include "Context.h" #include "Date.h" #include "Table.h" -#include "TDB.h" -#include "T.h" -#include "task.h" +#include "text.h" +#include "util.h" +#include "main.h" #ifdef HAVE_LIBNCURSES #include <ncurses.h> #endif +extern Context context; + //////////////////////////////////////////////////////////////////////////////// -void filterSequence (std::vector<T>& all, T& task) +std::string shortUsage () { - std::vector <int> sequence = task.getAllIds (); + Table table; - std::vector <T> filtered; - std::vector <T>::iterator t; - for (t = all.begin (); t != all.end (); ++t) - { - std::vector <int>::iterator s; - for (s = sequence.begin (); s != sequence.end (); ++s) - if (t->getId () == *s) - filtered.push_back (*t); - } + table.addColumn (" "); + table.addColumn (" "); + table.addColumn (" "); - if (sequence.size () != filtered.size ()) - { - std::vector <int> filteredSequence; - std::vector <T>::iterator fs; - for (fs = filtered.begin (); fs != filtered.end (); ++fs) - filteredSequence.push_back (fs->getId ()); - - std::vector <int> left; - std::vector <int> right; - listDiff (filteredSequence, sequence, left, right); - if (left.size ()) - throw std::string ("Sequence filtering error - please report this error"); - - if (right.size ()) - { - std::stringstream out; - out << "Task"; + table.setColumnJustification (0, Table::left); + table.setColumnJustification (1, Table::left); + table.setColumnJustification (2, Table::left); - if (right.size () > 1) out << "s"; + table.setColumnWidth (0, Table::minimum); + table.setColumnWidth (1, Table::minimum); + table.setColumnWidth (2, Table::flexible); + table.setTableWidth (context.getWidth ()); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); - std::vector <int>::iterator s; - for (s = right.begin (); s != right.end (); ++s) - out << " " << *s; + int row = table.addRow (); + table.addCell (row, 0, "Usage:"); + table.addCell (row, 1, "task"); - out << " not found"; - throw out.str (); - } - } + row = table.addRow (); + table.addCell (row, 1, "task add [tags] [attrs] desc..."); + table.addCell (row, 2, "Adds a new task."); - all = filtered; -} + row = table.addRow (); + table.addCell (row, 1, "task append [tags] [attrs] desc..."); + table.addCell (row, 2, "Appends more description to an existing task."); -//////////////////////////////////////////////////////////////////////////////// -void filter (std::vector<T>& all, T& task) -{ - std::vector <T> filtered; + row = table.addRow (); + table.addCell (row, 1, "task annotate ID desc..."); + table.addCell (row, 2, "Adds an annotation to an existing task."); - // Split any description specified into words. - std::vector <std::string> descWords; - split (descWords, lowerCase (task.getDescription ()), ' '); + row = table.addRow (); + table.addCell (row, 1, "task ID [tags] [attrs] [desc...]"); + table.addCell (row, 2, "Modifies the existing task with provided arguments."); - // Get all the tags to match against. - std::vector <std::string> tagList; - task.getTags (tagList); + row = table.addRow (); + table.addCell (row, 1, "task ID /from/to/g"); + table.addCell (row, 2, "Performs substitution on the task description and " + "annotations. The 'g' is optional, and causes " + "substitutions for all matching text, not just the " + "first occurrence."); - // Get all the attributes to match against. - std::map <std::string, std::string> attrList; - task.getAttributes (attrList); + row = table.addRow (); + table.addCell (row, 1, "task edit ID"); + table.addCell (row, 2, "Launches an editor to let you modify all aspects of a task directly, therefore it is to be used carefully."); - // Iterate over each task, and apply selection criteria. - for (unsigned int i = 0; i < all.size (); ++i) - { - T refTask (all[i]); + row = table.addRow (); + table.addCell (row, 1, "task undo"); + table.addCell (row, 2, "Reverts the most recent action."); - // Apply description filter. - std::string desc = lowerCase (refTask.getDescription ()); - unsigned int matches = 0; - for (unsigned int w = 0; w < descWords.size (); ++w) - if (desc.find (descWords[w]) != std::string::npos) - ++matches; +#ifdef FEATURE_SHELL + row = table.addRow (); + table.addCell (row, 1, "task shell"); + table.addCell (row, 2, "Launches an interactive shell."); +#endif - if (matches == descWords.size ()) - { - // Apply attribute filter. - matches = 0; - foreach (a, attrList) - { - if (a->first == "project") - { - if (a->second.length () <= refTask.getAttribute (a->first).length ()) - if (a->second == refTask.getAttribute (a->first).substr (0, a->second.length ())) - ++matches; -/* - TODO Attempt at allowing "pri:!H", thwarted by a lack of coffee and the - validation of "!H" as a priority value. To be revisited soon. - { - if (a->second[0] == '!') // Inverted search. - { - if (a->second.substr (1, std::string::npos) != refTask.getAttribute (a->first).substr (0, a->second.length ())) - ++matches; - } - else - { - if (a->second == refTask.getAttribute (a->first).substr (0, a->second.length ())) - ++matches; - } - } -*/ - } - else if (a->second == refTask.getAttribute (a->first)) - ++matches; -/* - else - { - if (a->second[0] == '!') // Inverted search. - { - if (a->second.substr (1, std::string::npos) != refTask.getAttribute (a->first)) - ++matches; - } - else - { - if (a->second == refTask.getAttribute (a->first)) - ++matches; - } - } -*/ - } + row = table.addRow (); + table.addCell (row, 1, "task duplicate ID [tags] [attrs] [desc...]"); + table.addCell (row, 2, "Duplicates the specified task, and allows modifications."); - if (matches == attrList.size ()) - { - // Apply tag filter. - matches = 0; - for (unsigned int t = 0; t < tagList.size (); ++t) - if (refTask.hasTag (tagList[t])) - ++matches; - - if (matches == tagList.size ()) - filtered.push_back (refTask); - } - } - } + row = table.addRow (); + table.addCell (row, 1, "task delete ID"); + table.addCell (row, 2, "Deletes the specified task."); - all = filtered; -} + row = table.addRow (); + table.addCell (row, 1, "task info ID"); + table.addCell (row, 2, "Shows all data, metadata for specified task."); -//////////////////////////////////////////////////////////////////////////////// -// Successively apply filters based on the task object built from the command -// line. Tasks that match all the specified criteria are listed. -std::string handleCompleted (TDB& tdb, T& task, Config& conf) -{ - std::stringstream out; + row = table.addRow (); + table.addCell (row, 1, "task start ID"); + table.addCell (row, 2, "Marks specified task as started."); - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif + row = table.addRow (); + table.addCell (row, 1, "task stop ID"); + table.addCell (row, 2, "Removes the 'start' time from a task."); - // Get the pending tasks. - std::vector <T> tasks; - tdb.completedT (tasks); - filter (tasks, task); + row = table.addRow (); + table.addCell (row, 1, "task done ID [tags] [attrs] [desc...]"); + table.addCell (row, 2, "Marks the specified task as completed."); - initializeColorRules (conf); + row = table.addRow (); + table.addCell (row, 1, "task projects"); + table.addCell (row, 2, "Shows a list of all project names used, and how many tasks are in each."); - // Create a table for output. - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - table.addColumn ("Done"); - table.addColumn ("Project"); - table.addColumn ("Description"); + row = table.addRow (); + table.addCell (row, 1, "task tags"); + table.addCell (row, 2, "Shows a list of all tags used."); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - table.setColumnUnderline (2); - } - else - table.setTableDashedUnderline (); + row = table.addRow (); + table.addCell (row, 1, "task summary"); + table.addCell (row, 2, "Shows a report of task status by project."); - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::minimum); - table.setColumnWidth (2, Table::flexible); + row = table.addRow (); + table.addCell (row, 1, "task timesheet [weeks]"); + table.addCell (row, 2, "Shows a weekly report of tasks completed and started."); - table.setColumnJustification (0, Table::right); - table.setColumnJustification (1, Table::left); - table.setColumnJustification (2, Table::left); + row = table.addRow (); + table.addCell (row, 1, "task history"); + table.addCell (row, 2, "Shows a report of task history, by month."); - // Note: There is deliberately no sorting. The original sorting was on the - // end date. Tasks are appended to completed.data naturally sorted by - // the end date, so that sequence is assumed to remain unchanged, and - // relied upon here. + row = table.addRow (); + table.addCell (row, 1, "task ghistory"); + table.addCell (row, 2, "Shows a graphical report of task history, by month."); - // Iterate over each task, and apply selection criteria. - for (unsigned int i = 0; i < tasks.size (); ++i) - { - T refTask (tasks[i]); + row = table.addRow (); + table.addCell (row, 1, "task calendar [due|month year|year]"); + table.addCell (row, 2, "Shows a calendar, with due tasks marked."); - // Now format the matching task. - Date end (::atoi (refTask.getAttribute ("end").c_str ())); + row = table.addRow (); + table.addCell (row, 1, "task stats"); + table.addCell (row, 2, "Shows task database statistics."); - // All criteria match, so add refTask to the output table. - int row = table.addRow (); + row = table.addRow (); + table.addCell (row, 1, "task import"); + table.addCell (row, 2, "Imports tasks from a variety of formats."); - table.addCell (row, 0, end.toString (conf.get ("dateformat", "m/d/Y"))); - table.addCell (row, 1, refTask.getAttribute ("project")); + row = table.addRow (); + table.addCell (row, 1, "task export"); + table.addCell (row, 2, "Lists all tasks in CSV format."); - std::string description = refTask.getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - refTask.getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } - table.addCell (row, 2, description); + row = table.addRow (); + table.addCell (row, 1, "task color"); + table.addCell (row, 2, "Displays all possible colors."); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (refTask.getAttribute ("fg")); - Text::color bg = Text::colorCode (refTask.getAttribute ("bg")); - autoColorize (refTask, fg, bg, conf); - table.setRowFg (row, fg); - table.setRowBg (row, bg); - } + row = table.addRow (); + table.addCell (row, 1, "task version"); + table.addCell (row, 2, "Shows the task version number."); + + row = table.addRow (); + table.addCell (row, 1, "task help"); + table.addCell (row, 2, "Shows the long usage text."); + + // Add custom reports here... + std::vector <std::string> all; + context.cmd.allCustomReports (all); + foreach (report, all) + { + std::string command = std::string ("task ") + *report + std::string (" [tags] [attrs] desc..."); + std::string description = context.config.get ( + std::string ("report.") + *report + ".description", std::string ("(missing description)")); + + row = table.addRow (); + table.addCell (row, 1, command); + table.addCell (row, 2, description); } - if (table.rowCount ()) - out << optionalBlankLine (conf) - << table.render () - << optionalBlankLine (conf) - << table.rowCount () - << (table.rowCount () == 1 ? " task" : " tasks") - << std::endl; - else - out << "No matches." - << std::endl; + std::stringstream out; + out << table.render () + << std::endl + << "See http://taskwarrior.org/wiki/taskwarrior/Download for the latest " + << "releases and a full tutorial. New releases containing fixes and " + << "enhancements are made frequently. Join in the discussion of task, " + << "present and future, at http://taskwarrior.org" + << std::endl + << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -// Display all information for the given task. -std::string handleInfo (TDB& tdb, T& task, Config& conf) +std::string longUsage () { std::stringstream out; + out << shortUsage () + << "ID is the numeric identifier displayed by the 'task list' command. " + << "You can specify multiple IDs for task commands, and multiple tasks " + << "will be affected. To specify multiple IDs make sure you use one " + << "of these forms:" << "\n" + << " task delete 1,2,3" << "\n" + << " task info 1-3" << "\n" + << " task pri:H 1,2-5,19" << "\n" + << "\n" + << "Tags are arbitrary words, any quantity:" << "\n" + << " +tag The + means add the tag" << "\n" + << " -tag The - means remove the tag" << "\n" + << "\n" + << "Attributes are:" << "\n" + << " project: Project name" << "\n" + << " priority: Priority" << "\n" + << " due: Due date" << "\n" + << " recur: Recurrence frequency" << "\n" + << " until: Recurrence end date" << "\n" + << " fg: Foreground color" << "\n" + << " bg: Background color" << "\n" + << " limit: Desired number of rows in report" << "\n" + << " wait: Date until task becomes pending" << "\n" + << "\n" + << "Attribute modifiers improve filters. Supported modifiers are:" << "\n" + << " before (synonyms under, below)" << "\n" + << " after (synonyms over, above)" << "\n" + << " none" << "\n" + << " any" << "\n" + << " is (synonym equals)" << "\n" + << " isnt (synonym not)" << "\n" + << " has (synonym contain)" << "\n" + << " hasnt" << "\n" + << " startswith (synonym left)" << "\n" + << " endswith (synonym right)" << "\n" + << "\n" + << " For example:" << "\n" + << " task list due.before:eom priority.not:L" << "\n" + << "\n" + << "The default .taskrc file can be overridden with:" << "\n" + << " task rc:<alternate file> ..." << "\n" + << "\n" + << "The values in .taskrc (or alternate) can be overridden with:" << "\n" + << " task ... rc.<name>:<value>" << "\n" + << "\n" + << "Any command or attribute name may be abbreviated if still unique:" << "\n" + << " task list project:Home" << "\n" + << " task li pro:Home" << "\n" + << "\n" + << "Some task descriptions need to be escaped because of the shell:" << "\n" + << " task add \"quoted ' quote\"" << "\n" + << " task add escaped \\' quote" << "\n" + << "\n" + << "The argument -- tells task to treat all other args as description." << "\n" + << " task add -- project:Home needs scheduling" << "\n" + << "\n" + << "Many characters have special meaning to the shell, including:" << "\n" + << " $ ! ' \" ( ) ; \\ ` * ? { } [ ] < > | & % # ~" << "\n" + << std::endl; - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif + return out.str (); +} +//////////////////////////////////////////////////////////////////////////////// +// Display all information for the given task. +std::string handleInfo () +{ // Get all the tasks. - std::vector <T> tasks; - tdb.allPendingT (tasks); + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.loadPending (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); + + // Filter sequence. + context.filter.applySequence (tasks, context.sequence); // Find the task. - int count = 0; - for (unsigned int i = 0; i < tasks.size (); ++i) + std::stringstream out; + foreach (task, tasks) { - T refTask (tasks[i]); + Table table; + table.setTableWidth (context.getWidth ()); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); + + table.addColumn ("Name"); + table.addColumn ("Value"); - if (refTask.getId () == task.getId () || task.sequenceContains (refTask.getId ())) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { - ++count; + table.setColumnUnderline (0); + table.setColumnUnderline (1); + } + else + table.setTableDashedUnderline (); - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setColumnWidth (0, Table::minimum); + table.setColumnWidth (1, Table::flexible); - table.addColumn ("Name"); - table.addColumn ("Value"); + table.setColumnJustification (0, Table::left); + table.setColumnJustification (1, Table::left); + Date now; - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - } - else - table.setTableDashedUnderline (); + int row = table.addRow (); + table.addCell (row, 0, "ID"); + table.addCell (row, 1, task->id); - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::flexible); + std::string status = ucFirst (Task::statusToText (task->getStatus ())); - table.setColumnJustification (0, Table::left); - table.setColumnJustification (1, Table::left); - Date now; + if (task->has ("parent")) + status += " (Recurring)"; - int row = table.addRow (); - table.addCell (row, 0, "ID"); - table.addCell (row, 1, refTask.getId ()); + row = table.addRow (); + table.addCell (row, 0, "Status"); + table.addCell (row, 1, status); - std::string status = refTask.getStatus () == T::pending ? "Pending" - : refTask.getStatus () == T::completed ? "Completed" - : refTask.getStatus () == T::deleted ? "Deleted" - : refTask.getStatus () == T::recurring ? "Recurring" - : ""; - if (refTask.getAttribute ("parent") != "") - status += " (Recurring)"; + row = table.addRow (); + table.addCell (row, 0, "Description"); + table.addCell (row, 1, getFullDescription (*task)); + if (task->has ("project")) + { row = table.addRow (); - table.addCell (row, 0, "Status"); - table.addCell (row, 1, status); - - std::string description = refTask.getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - refTask.getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } + table.addCell (row, 0, "Project"); + table.addCell (row, 1, task->get ("project")); + } + if (task->has ("priority")) + { row = table.addRow (); - table.addCell (row, 0, "Description"); - table.addCell (row, 1, description); + table.addCell (row, 0, "Priority"); + table.addCell (row, 1, task->get ("priority")); + } - if (refTask.getAttribute ("project") != "") + if (task->getStatus () == Task::recurring || + task->has ("parent")) + { + if (task->has ("recur")) { row = table.addRow (); - table.addCell (row, 0, "Project"); - table.addCell (row, 1, refTask.getAttribute ("project")); + table.addCell (row, 0, "Recurrence"); + table.addCell (row, 1, task->get ("recur")); } - if (refTask.getAttribute ("priority") != "") + if (task->has ("until")) { row = table.addRow (); - table.addCell (row, 0, "Priority"); - table.addCell (row, 1, refTask.getAttribute ("priority")); + table.addCell (row, 0, "Recur until"); + table.addCell (row, 1, task->get ("until")); } - if (refTask.getStatus () == T::recurring || - refTask.getAttribute ("parent") != "") + if (task->has ("mask")) { - if (refTask.getAttribute ("recur") != "") - { - row = table.addRow (); - table.addCell (row, 0, "Recurrence"); - table.addCell (row, 1, refTask.getAttribute ("recur")); - } - - if (refTask.getAttribute ("until") != "") - { - row = table.addRow (); - table.addCell (row, 0, "Recur until"); - table.addCell (row, 1, refTask.getAttribute ("until")); - } - - if (refTask.getAttribute ("mask") != "") - { - row = table.addRow (); - table.addCell (row, 0, "Mask"); - table.addCell (row, 1, refTask.getAttribute ("mask")); - } - - if (refTask.getAttribute ("parent") != "") - { - row = table.addRow (); - table.addCell (row, 0, "Parent task"); - table.addCell (row, 1, refTask.getAttribute ("parent")); - } - row = table.addRow (); - table.addCell (row, 0, "Mask Index"); - table.addCell (row, 1, refTask.getAttribute ("imask")); + table.addCell (row, 0, "Mask"); + table.addCell (row, 1, task->get ("mask")); } - // due (colored) - bool imminent = false; - bool overdue = false; - std::string due = refTask.getAttribute ("due"); - if (due != "") + if (task->has ("parent")) { row = table.addRow (); - table.addCell (row, 0, "Due"); + table.addCell (row, 0, "Parent task"); + table.addCell (row, 1, task->get ("parent")); + } - Date dt (::atoi (due.c_str ())); - due = dt.toString (conf.get ("dateformat", "m/d/Y")); - table.addCell (row, 1, due); + row = table.addRow (); + table.addCell (row, 0, "Mask Index"); + table.addCell (row, 1, task->get ("imask")); + } - if (due.length ()) - { - overdue = (dt < now) ? true : false; - Date nextweek = now + 7 * 86400; - imminent = dt < nextweek ? true : false; + // due (colored) + bool imminent = false; + bool overdue = false; + if (task->has ("due")) + { + row = table.addRow (); + table.addCell (row, 0, "Due"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - if (overdue) - table.setCellFg (row, 1, Text::colorCode (conf.get ("color.overdue", "red"))); - else if (imminent) - table.setCellFg (row, 1, Text::colorCode (conf.get ("color.due", "yellow"))); - } - } - } + Date dt (::atoi (task->get ("due").c_str ())); + std::string due = getDueDate (*task); + table.addCell (row, 1, due); - // start - if (refTask.getAttribute ("start") != "") - { - row = table.addRow (); - table.addCell (row, 0, "Start"); - Date dt (::atoi (refTask.getAttribute ("start").c_str ())); - table.addCell (row, 1, dt.toString (conf.get ("dateformat", "m/d/Y"))); - } + overdue = (dt < now) ? true : false; + Date nextweek = now + 7 * 86400; + imminent = dt < nextweek ? true : false; - // end - if (refTask.getAttribute ("end") != "") + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) { - row = table.addRow (); - table.addCell (row, 0, "End"); - Date dt (::atoi (refTask.getAttribute ("end").c_str ())); - table.addCell (row, 1, dt.toString (conf.get ("dateformat", "m/d/Y"))); + if (overdue) + table.setCellFg (row, 1, Text::colorCode (context.config.get ("color.overdue", "red"))); + else if (imminent) + table.setCellFg (row, 1, Text::colorCode (context.config.get ("color.due", "yellow"))); } + } - // tags ... - std::vector <std::string> tags; - refTask.getTags (tags); - if (tags.size ()) - { - std::string allTags; - join (allTags, " ", tags); + // wait + if (task->has ("wait")) + { + row = table.addRow (); + table.addCell (row, 0, "Waiting until"); + Date dt (::atoi (task->get ("wait").c_str ())); + table.addCell (row, 1, dt.toString (context.config.get ("dateformat", "m/d/Y"))); + } - row = table.addRow (); - table.addCell (row, 0, "Tags"); - table.addCell (row, 1, allTags); - } + // start + if (task->has ("start")) + { + row = table.addRow (); + table.addCell (row, 0, "Start"); + Date dt (::atoi (task->get ("start").c_str ())); + table.addCell (row, 1, dt.toString (context.config.get ("dateformat", "m/d/Y"))); + } - // uuid + // end + if (task->has ("end")) + { row = table.addRow (); - table.addCell (row, 0, "UUID"); - table.addCell (row, 1, refTask.getUUID ()); + table.addCell (row, 0, "End"); + Date dt (::atoi (task->get ("end").c_str ())); + table.addCell (row, 1, dt.toString (context.config.get ("dateformat", "m/d/Y"))); + } + + // tags ... + std::vector <std::string> tags; + task->getTags (tags); + if (tags.size ()) + { + std::string allTags; + join (allTags, " ", tags); - // entry row = table.addRow (); - table.addCell (row, 0, "Entered"); - Date dt (::atoi (refTask.getAttribute ("entry").c_str ())); - std::string entry = dt.toString (conf.get ("dateformat", "m/d/Y")); + table.addCell (row, 0, "Tags"); + table.addCell (row, 1, allTags); + } - std::string age; - std::string created = refTask.getAttribute ("entry"); - if (created.length ()) - { - Date dt (::atoi (created.c_str ())); - formatTimeDeltaDays (age, (time_t) (now - dt)); - } + // uuid + row = table.addRow (); + table.addCell (row, 0, "UUID"); + table.addCell (row, 1, task->get ("uuid")); - table.addCell (row, 1, entry + " (" + age + ")"); + // entry + row = table.addRow (); + table.addCell (row, 0, "Entered"); + Date dt (::atoi (task->get ("entry").c_str ())); + std::string entry = dt.toString (context.config.get ("dateformat", "m/d/Y")); - // fg - std::string color = refTask.getAttribute ("fg"); - if (color != "") - { - row = table.addRow (); - table.addCell (row, 0, "Foreground color"); - table.addCell (row, 1, color); - } + std::string age; + std::string created = task->get ("entry"); + if (created.length ()) + { + Date dt (::atoi (created.c_str ())); + age = formatSeconds ((time_t) (now - dt)); + } - // bg - color = refTask.getAttribute ("bg"); - if (color != "") - { - row = table.addRow (); - table.addCell (row, 0, "Background color"); - table.addCell (row, 1, color); - } + table.addCell (row, 1, entry + " (" + age + ")"); - out << optionalBlankLine (conf) - << table.render () - << std::endl; + // fg + std::string color = task->get ("fg"); + if (color != "") + { + row = table.addRow (); + table.addCell (row, 0, "Foreground color"); + table.addCell (row, 1, color); + } + + // bg + color = task->get ("bg"); + if (color != "") + { + row = table.addRow (); + table.addCell (row, 0, "Background color"); + table.addCell (row, 1, color); } + + out << optionalBlankLine () + << table.render () + << std::endl; } - if (! count) + if (! tasks.size ()) out << "No matches." << std::endl; return out.str (); @@ -540,20 +507,21 @@ std::string handleInfo (TDB& tdb, T& task, Config& conf) // Project Remaining Avg Age Complete 0% 100% // A 12 13d 55% XXXXXXXXXXXXX----------- // B 109 3d 12h 10% XXX--------------------- -std::string handleReportSummary (TDB& tdb, T& task, Config& conf) +std::string handleReportSummary () { - std::stringstream out; - - std::vector <T> tasks; - tdb.allT (tasks); - handleRecurrence (tdb, tasks); - filter (tasks, task); + // Scan the pending tasks. + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); // Generate unique list of project names from all pending tasks. std::map <std::string, bool> allProjects; - foreach (t, tasks) - if (t->getStatus () == T::pending) - allProjects[t->getAttribute ("project")] = false; + foreach (task, tasks) + if (task->getStatus () == Task::pending) + allProjects[task->get ("project")] = false; // Initialize counts, sum. std::map <std::string, int> countPending; @@ -563,35 +531,36 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) time_t now = time (NULL); // Initialize counters. - foreach (i, allProjects) + foreach (project, allProjects) { - countPending [i->first] = 0; - countCompleted [i->first] = 0; - sumEntry [i->first] = 0.0; - counter [i->first] = 0; + countPending [project->first] = 0; + countCompleted [project->first] = 0; + sumEntry [project->first] = 0.0; + counter [project->first] = 0; } // Count the various tasks. - foreach (t, tasks) + foreach (task, tasks) { - std::string project = t->getAttribute ("project"); + std::string project = task->get ("project"); ++counter[project]; - if (t->getStatus () == T::pending) + if (task->getStatus () == Task::pending || + task->getStatus () == Task::waiting) { ++countPending[project]; - time_t entry = ::atoi (t->getAttribute ("entry").c_str ()); + time_t entry = ::atoi (task->get ("entry").c_str ()); if (entry) sumEntry[project] = sumEntry[project] + (double) (now - entry); } - else if (t->getStatus () == T::completed) + else if (task->getStatus () == Task::completed) { ++countCompleted[project]; - time_t entry = ::atoi (t->getAttribute ("entry").c_str ()); - time_t end = ::atoi (task.getAttribute ("end").c_str ()); + time_t entry = ::atoi (task->get ("entry").c_str ()); + time_t end = ::atoi (task->get ("end").c_str ()); if (entry && end) sumEntry[project] = sumEntry[project] + (double) (end - entry); } @@ -605,7 +574,8 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) table.addColumn ("Complete"); table.addColumn ("0% 100%"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { table.setColumnUnderline (0); table.setColumnUnderline (1); @@ -620,7 +590,7 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) table.setColumnJustification (3, Table::right); table.sortOn (0, Table::ascendingCharacter); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); int barWidth = 30; foreach (i, allProjects) @@ -633,7 +603,7 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) if (counter[i->first]) { std::string age; - formatTimeDeltaDays (age, (time_t) (sumEntry[i->first] / counter[i->first])); + age = formatSeconds ((time_t) (sumEntry[i->first] / counter[i->first])); table.addCell (row, 2, age); } @@ -642,7 +612,7 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) int completedBar = (c * barWidth) / (c + p); std::string bar; - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) { bar = "\033[42m"; for (int b = 0; b < completedBar; ++b) @@ -670,10 +640,11 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) } } + std::stringstream out; if (table.rowCount ()) - out << optionalBlankLine (conf) + out << optionalBlankLine () << table.render () - << optionalBlankLine (conf) + << optionalBlankLine () << table.rowCount () << (table.rowCount () == 1 ? " project" : " projects") << std::endl; @@ -702,173 +673,59 @@ std::string handleReportSummary (TDB& tdb, T& task, Config& conf) // // Make the "three" tasks a configurable number // -std::string handleReportNext (TDB& tdb, T& task, Config& conf) +std::string handleReportNext () { - std::stringstream out; - - // Load all pending. - std::vector <T> pending; - tdb.allPendingT (pending); - handleRecurrence (tdb, pending); - filter (pending, task); - - // Restrict to matching subset. - std::vector <int> matching; - gatherNextTasks (tdb, task, conf, pending, matching); - - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - - // Get the pending tasks. - std::vector <T> tasks; - tdb.pendingT (tasks); - filter (tasks, task); - - initializeColorRules (conf); - - // Create a table for output. - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - table.addColumn ("ID"); - table.addColumn ("Project"); - table.addColumn ("Pri"); - table.addColumn ("Due"); - table.addColumn ("Active"); - table.addColumn ("Age"); - table.addColumn ("Description"); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - table.setColumnUnderline (2); - table.setColumnUnderline (3); - table.setColumnUnderline (4); - table.setColumnUnderline (5); - table.setColumnUnderline (6); - } - else - table.setTableDashedUnderline (); - - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::minimum); - table.setColumnWidth (2, Table::minimum); - table.setColumnWidth (3, Table::minimum); - table.setColumnWidth (4, Table::minimum); - table.setColumnWidth (5, Table::minimum); - table.setColumnWidth (6, Table::flexible); - - table.setColumnJustification (0, Table::right); - table.setColumnJustification (3, Table::right); - table.setColumnJustification (5, Table::right); - - table.sortOn (3, Table::ascendingDate); - table.sortOn (2, Table::descendingPriority); - table.sortOn (1, Table::ascendingCharacter); + // Load report configuration. + std::string columnList = context.config.get ("report.next.columns"); + std::string labelList = context.config.get ("report.next.labels"); + std::string sortList = context.config.get ("report.next.sort"); + std::string filterList = context.config.get ("report.next.filter"); - // Iterate over each task, and apply selection criteria. - foreach (i, matching) + std::vector <std::string> filterArgs; + split (filterArgs, filterList, ' '); { - T refTask (pending[*i]); - Date now; - - // Now format the matching task. - bool imminent = false; - bool overdue = false; - std::string due = refTask.getAttribute ("due"); - if (due.length ()) - { - switch (getDueState (due)) - { - case 2: overdue = true; break; - case 1: imminent = true; break; - case 0: - default: break; - } - - Date dt (::atoi (due.c_str ())); - due = dt.toString (conf.get ("dateformat", "m/d/Y")); - } - - std::string active; - if (refTask.getAttribute ("start") != "") - active = "*"; - - std::string age; - std::string created = refTask.getAttribute ("entry"); - if (created.length ()) - { - Date dt (::atoi (created.c_str ())); - formatTimeDeltaDays (age, (time_t) (now - dt)); - } - - // All criteria match, so add refTask to the output table. - int row = table.addRow (); - table.addCell (row, 0, refTask.getId ()); - table.addCell (row, 1, refTask.getAttribute ("project")); - table.addCell (row, 2, refTask.getAttribute ("priority")); - table.addCell (row, 3, due); - table.addCell (row, 4, active); - table.addCell (row, 5, age); - - std::string description = refTask.getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - refTask.getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } + Cmd cmd ("next"); + Task task; + Sequence sequence; + Subst subst; + Filter filter; + context.parse (filterArgs, cmd, task, sequence, subst, filter); - table.addCell (row, 6, description); + context.sequence.combine (sequence); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (refTask.getAttribute ("fg")); - Text::color bg = Text::colorCode (refTask.getAttribute ("bg")); - autoColorize (refTask, fg, bg, conf); - table.setRowFg (row, fg); - table.setRowBg (row, bg); + // Allow limit to be overridden by the command line. + if (!context.task.has ("limit") && task.has ("limit")) + context.task.set ("limit", task.get ("limit")); - if (fg == Text::nocolor) - { - if (overdue) - table.setCellFg (row, 3, Text::colorCode (conf.get ("color.overdue", "red"))); - else if (imminent) - table.setCellFg (row, 3, Text::colorCode (conf.get ("color.due", "yellow"))); - } - } + foreach (att, filter) + context.filter.push_back (*att); } - if (table.rowCount ()) - out << optionalBlankLine (conf) - << table.render () - << optionalBlankLine (conf) - << table.rowCount () - << (table.rowCount () == 1 ? " task" : " tasks") - << std::endl; - else - out << "No matches." - << std::endl; + // Get all the tasks. + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); - return out.str (); + // Restrict to matching subset. + gatherNextTasks (tasks); + + return runCustomReport ( + "next", + columnList, + labelList, + sortList, + filterList, + tasks); } //////////////////////////////////////////////////////////////////////////////// // Year Month Added Completed Deleted // 2006 November 87 63 14 -// 2006 December 21 6 1 +// December 21 6 1 +// 2007 January 3 12 0 time_t monthlyEpoch (const std::string& date) { // Convert any date in epoch form to m/d/y, then convert back @@ -887,100 +744,60 @@ time_t monthlyEpoch (const std::string& date) return 0; } -std::string handleReportHistory (TDB& tdb, T& task, Config& conf) +std::string handleReportHistory () { - std::stringstream out; - - std::map <time_t, int> groups; - std::map <time_t, int> addedGroup; - std::map <time_t, int> completedGroup; - std::map <time_t, int> deletedGroup; + std::map <time_t, int> groups; // Represents any month with data + std::map <time_t, int> addedGroup; // Additions by month + std::map <time_t, int> completedGroup; // Completions by month + std::map <time_t, int> deletedGroup; // Deletions by month // Scan the pending tasks. - std::vector <T> pending; - tdb.allPendingT (pending); - handleRecurrence (tdb, pending); - filter (pending, task); - for (unsigned int i = 0; i < pending.size (); ++i) + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); + + foreach (task, tasks) { - T task (pending[i]); - time_t epoch = monthlyEpoch (task.getAttribute ("entry")); - if (epoch) + time_t epoch = monthlyEpoch (task->get ("entry")); + groups[epoch] = 0; + + // Every task has an entry date. + if (addedGroup.find (epoch) != addedGroup.end ()) + addedGroup[epoch] = addedGroup[epoch] + 1; + else + addedGroup[epoch] = 1; + + // All deleted tasks have an end date. + if (task->getStatus () == Task::deleted) { + epoch = monthlyEpoch (task->get ("end")); groups[epoch] = 0; - if (addedGroup.find (epoch) != addedGroup.end ()) - addedGroup[epoch] = addedGroup[epoch] + 1; + if (deletedGroup.find (epoch) != deletedGroup.end ()) + deletedGroup[epoch] = deletedGroup[epoch] + 1; else - addedGroup[epoch] = 1; - - if (task.getStatus () == T::deleted) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (deletedGroup.find (epoch) != deletedGroup.end ()) - deletedGroup[epoch] = deletedGroup[epoch] + 1; - else - deletedGroup[epoch] = 1; - } - else if (task.getStatus () == T::completed) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (completedGroup.find (epoch) != completedGroup.end ()) - completedGroup[epoch] = completedGroup[epoch] + 1; - else - completedGroup[epoch] = 1; - } + deletedGroup[epoch] = 1; } - } - // Scan the completed tasks. - std::vector <T> completed; - tdb.allCompletedT (completed); - filter (completed, task); - for (unsigned int i = 0; i < completed.size (); ++i) - { - T task (completed[i]); - time_t epoch = monthlyEpoch (task.getAttribute ("entry")); - if (epoch) + // All completed tasks have an end date. + else if (task->getStatus () == Task::completed) { + epoch = monthlyEpoch (task->get ("end")); groups[epoch] = 0; - if (addedGroup.find (epoch) != addedGroup.end ()) - addedGroup[epoch] = addedGroup[epoch] + 1; + if (completedGroup.find (epoch) != completedGroup.end ()) + completedGroup[epoch] = completedGroup[epoch] + 1; else - addedGroup[epoch] = 1; - - epoch = monthlyEpoch (task.getAttribute ("end")); - if (task.getStatus () == T::deleted) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (deletedGroup.find (epoch) != deletedGroup.end ()) - deletedGroup[epoch] = deletedGroup[epoch] + 1; - else - deletedGroup[epoch] = 1; - } - else if (task.getStatus () == T::completed) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (completedGroup.find (epoch) != completedGroup.end ()) - completedGroup[epoch] = completedGroup[epoch] + 1; - else - completedGroup[epoch] = 1; - } + completedGroup[epoch] = 1; } } // Now build the table. Table table; - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); table.addColumn ("Year"); table.addColumn ("Month"); table.addColumn ("Added"); @@ -988,7 +805,8 @@ std::string handleReportHistory (TDB& tdb, T& task, Config& conf) table.addColumn ("Deleted"); table.addColumn ("Net"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { table.setColumnUnderline (0); table.setColumnUnderline (1); @@ -1051,7 +869,7 @@ std::string handleReportHistory (TDB& tdb, T& task, Config& conf) } table.addCell (row, 5, net); - if ((conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) && net) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && net) table.setCellFg (row, 5, net > 0 ? Text::red: Text::green); } @@ -1061,15 +879,16 @@ std::string handleReportHistory (TDB& tdb, T& task, Config& conf) row = table.addRow (); table.addCell (row, 1, "Average"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) table.setRowFg (row, Text::bold); - table.addCell (row, 2, totalAdded / (table.rowCount () - 2)); + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) table.setRowFg (row, Text::bold); + table.addCell (row, 2, totalAdded / (table.rowCount () - 2)); table.addCell (row, 3, totalCompleted / (table.rowCount () - 2)); - table.addCell (row, 4, totalDeleted / (table.rowCount () - 2)); + table.addCell (row, 4, totalDeleted / (table.rowCount () - 2)); table.addCell (row, 5, (totalAdded - totalCompleted - totalDeleted) / (table.rowCount () - 2)); } + std::stringstream out; if (table.rowCount ()) - out << optionalBlankLine (conf) + out << optionalBlankLine () << table.render () << std::endl; else @@ -1079,117 +898,68 @@ std::string handleReportHistory (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// -std::string handleReportGHistory (TDB& tdb, T& task, Config& conf) +std::string handleReportGHistory () { - std::stringstream out; + std::map <time_t, int> groups; // Represents any month with data + std::map <time_t, int> addedGroup; // Additions by month + std::map <time_t, int> completedGroup; // Completions by month + std::map <time_t, int> deletedGroup; // Deletions by month - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) + // Scan the pending tasks. + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); + + foreach (task, tasks) { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - int widthOfBar = width - 15; // 15 == strlen ("2008 September ") + time_t epoch = monthlyEpoch (task->get ("entry")); + groups[epoch] = 0; - std::map <time_t, int> groups; - std::map <time_t, int> addedGroup; - std::map <time_t, int> completedGroup; - std::map <time_t, int> deletedGroup; + // Every task has an entry date. + if (addedGroup.find (epoch) != addedGroup.end ()) + addedGroup[epoch] = addedGroup[epoch] + 1; + else + addedGroup[epoch] = 1; - // Scan the pending tasks. - std::vector <T> pending; - tdb.allPendingT (pending); - handleRecurrence (tdb, pending); - filter (pending, task); - for (unsigned int i = 0; i < pending.size (); ++i) - { - T task (pending[i]); - time_t epoch = monthlyEpoch (task.getAttribute ("entry")); - if (epoch) + // All deleted tasks have an end date. + if (task->getStatus () == Task::deleted) { + epoch = monthlyEpoch (task->get ("end")); groups[epoch] = 0; - if (addedGroup.find (epoch) != addedGroup.end ()) - addedGroup[epoch] = addedGroup[epoch] + 1; + if (deletedGroup.find (epoch) != deletedGroup.end ()) + deletedGroup[epoch] = deletedGroup[epoch] + 1; else - addedGroup[epoch] = 1; - - if (task.getStatus () == T::deleted) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (deletedGroup.find (epoch) != deletedGroup.end ()) - deletedGroup[epoch] = deletedGroup[epoch] + 1; - else - deletedGroup[epoch] = 1; - } - else if (task.getStatus () == T::completed) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (completedGroup.find (epoch) != completedGroup.end ()) - completedGroup[epoch] = completedGroup[epoch] + 1; - else - completedGroup[epoch] = 1; - } + deletedGroup[epoch] = 1; } - } - // Scan the completed tasks. - std::vector <T> completed; - tdb.allCompletedT (completed); - filter (completed, task); - for (unsigned int i = 0; i < completed.size (); ++i) - { - T task (completed[i]); - time_t epoch = monthlyEpoch (task.getAttribute ("entry")); - if (epoch) + // All completed tasks have an end date. + else if (task->getStatus () == Task::completed) { + epoch = monthlyEpoch (task->get ("end")); groups[epoch] = 0; - if (addedGroup.find (epoch) != addedGroup.end ()) - addedGroup[epoch] = addedGroup[epoch] + 1; + if (completedGroup.find (epoch) != completedGroup.end ()) + completedGroup[epoch] = completedGroup[epoch] + 1; else - addedGroup[epoch] = 1; - - epoch = monthlyEpoch (task.getAttribute ("end")); - if (task.getStatus () == T::deleted) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (deletedGroup.find (epoch) != deletedGroup.end ()) - deletedGroup[epoch] = deletedGroup[epoch] + 1; - else - deletedGroup[epoch] = 1; - } - else if (task.getStatus () == T::completed) - { - epoch = monthlyEpoch (task.getAttribute ("end")); - groups[epoch] = 0; - - if (completedGroup.find (epoch) != completedGroup.end ()) - completedGroup[epoch] = completedGroup[epoch] + 1; - else - completedGroup[epoch] = 1; - } + completedGroup[epoch] = 1; } } + int widthOfBar = context.getWidth () - 15; // 15 == strlen ("2008 September ") + // Now build the table. Table table; - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); table.addColumn ("Year"); table.addColumn ("Month"); table.addColumn ("Number Added/Completed/Deleted"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { table.setColumnUnderline (0); table.setColumnUnderline (1); @@ -1245,7 +1015,7 @@ std::string handleReportGHistory (TDB& tdb, T& task, Config& conf) unsigned int deletedBar = (widthOfBar * deletedGroup[i->first]) / maxLine; std::string bar = ""; - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) { char number[24]; std::string aBar = ""; @@ -1298,20 +1068,21 @@ std::string handleReportGHistory (TDB& tdb, T& task, Config& conf) } } + std::stringstream out; if (table.rowCount ()) { - out << optionalBlankLine (conf) + out << optionalBlankLine () << table.render () << std::endl; - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) out << "Legend: " << Text::colorize (Text::black, Text::on_red, "added") << ", " << Text::colorize (Text::black, Text::on_green, "completed") << ", " << Text::colorize (Text::black, Text::on_yellow, "deleted") - << optionalBlankLine (conf) + << optionalBlankLine () << std::endl; else out << "Legend: + added, X completed, - deleted" << std::endl; @@ -1323,31 +1094,24 @@ std::string handleReportGHistory (TDB& tdb, T& task, Config& conf) } //////////////////////////////////////////////////////////////////////////////// -std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) +std::string handleReportTimesheet () { - std::stringstream out; - - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif + // Scan the pending tasks. + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); - // Get all the tasks. - std::vector <T> tasks; - tdb.allT (tasks); - filter (tasks, task); + // Just do this once. + int width = context.getWidth (); // What day of the week does the user consider the first? - int weekStart = Date::dayOfWeek (conf.get ("weekstart", "Monday")); - if (weekStart == -1) - throw std::string ("The 'weekstart' configuration variable does " - "not contain a day name, such as 'Monday'."); + int weekStart = Date::dayOfWeek (context.config.get ("weekstart", "Sunday")); + if (weekStart != 0 && weekStart != 1) + throw std::string ("The 'weekstart' configuration variable may " + "only contain 'Sunday' or 'Monday'."); // Determine the date of the first day of the most recent report. Date today; @@ -1356,22 +1120,26 @@ std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) // Roll back to midnight. start = Date (start.month (), start.day (), start.year ()); - Date end = start + (7 * 86400) - 1; + Date end = start + (7 * 86400); // Determine how many reports to run. int quantity = 1; - std::vector <int> sequence = task.getAllIds (); - if (sequence.size () == 1) - quantity = sequence[0]; + if (context.sequence.size () == 1) + quantity = context.sequence[0]; + bool color = context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false); + + std::stringstream out; for (int week = 0; week < quantity; ++week) { + Date endString (end); + endString -= 86400; out << std::endl - << Text::colorize (Text::bold, Text::nocolor) - << start.toString (conf.get ("dateformat", "m/d/Y")) + << (color ? Text::colorize (Text::bold, Text::nocolor) : "") + << start.toString (context.config.get ("dateformat", "m/d/Y")) << " - " - << end.toString (conf.get ("dateformat", "m/d/Y")) - << Text::colorize () + << endString.toString (context.config.get ("dateformat", "m/d/Y")) + << (color ? Text::colorize () : "") << std::endl; // Render the completed table. @@ -1382,9 +1150,14 @@ std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) completed.addColumn ("Due"); completed.addColumn ("Description"); - completed.setColumnUnderline (1); - completed.setColumnUnderline (2); - completed.setColumnUnderline (3); + if (color && context.config.get (std::string ("fontunderline"), "true")) + { + completed.setColumnUnderline (1); + completed.setColumnUnderline (2); + completed.setColumnUnderline (3); + } + else + completed.setTableDashedUnderline (); completed.setColumnWidth (0, Table::minimum); completed.setColumnWidth (1, Table::minimum); @@ -1396,42 +1169,24 @@ std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) completed.setColumnJustification (2, Table::right); completed.setColumnJustification (3, Table::left); - foreach (t, tasks) + foreach (task, tasks) { // If task completed within range. - if (t->getStatus () == T::completed) + if (task->getStatus () == Task::completed) { - Date compDate (::atoi (t->getAttribute ("end").c_str ())); + Date compDate (::atoi (task->get ("end").c_str ())); if (compDate >= start && compDate < end) { int row = completed.addRow (); - completed.addCell (row, 1, t->getAttribute ("project")); - - std::string due = t->getAttribute ("due"); - if (due.length ()) - { - Date d (::atoi (due.c_str ())); - due = d.toString (conf.get ("dateformat", "m/d/Y")); - completed.addCell (row, 2, due); - } + completed.addCell (row, 1, task->get ("project")); + completed.addCell (row, 2, getDueDate (*task)); + completed.addCell (row, 3, getFullDescription (*task)); - std::string description = t->getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - t->getAnnotations (annotations); - foreach (anno, annotations) + if (color) { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } - completed.addCell (row, 3, description); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (t->getAttribute ("fg")); - Text::color bg = Text::colorCode (t->getAttribute ("bg")); - autoColorize (*t, fg, bg, conf); + Text::color fg = Text::colorCode (task->get ("fg")); + Text::color bg = Text::colorCode (task->get ("bg")); + autoColorize (*task, fg, bg); completed.setRowFg (row, fg); completed.setRowBg (row, bg); } @@ -1453,9 +1208,14 @@ std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) started.addColumn ("Due"); started.addColumn ("Description"); - started.setColumnUnderline (1); - started.setColumnUnderline (2); - started.setColumnUnderline (3); + if (color && context.config.get (std::string ("fontunderline"), "true")) + { + completed.setColumnUnderline (1); + completed.setColumnUnderline (2); + completed.setColumnUnderline (3); + } + else + completed.setTableDashedUnderline (); started.setColumnWidth (0, Table::minimum); started.setColumnWidth (1, Table::minimum); @@ -1466,43 +1226,25 @@ std::string handleReportTimesheet (TDB& tdb, T& task, Config& conf) started.setColumnJustification (1, Table::left); started.setColumnJustification (2, Table::right); started.setColumnJustification (3, Table::left); - foreach (t, tasks) + foreach (task, tasks) { // If task started within range, but not completed withing range. - if (t->getStatus () == T::pending && - t->getAttribute ("start") != "") + if (task->getStatus () == Task::pending && + task->has ("start")) { - Date startDate (::atoi (t->getAttribute ("start").c_str ())); + Date startDate (::atoi (task->get ("start").c_str ())); if (startDate >= start && startDate < end) { int row = started.addRow (); - started.addCell (row, 1, t->getAttribute ("project")); - - std::string due = t->getAttribute ("due"); - if (due.length ()) - { - Date d (::atoi (due.c_str ())); - due = d.toString (conf.get ("dateformat", "m/d/Y")); - started.addCell (row, 2, due); - } - - std::string description = t->getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - t->getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } - started.addCell (row, 3, description); + started.addCell (row, 1, task->get ("project")); + started.addCell (row, 2, getDueDate (*task)); + started.addCell (row, 3, getFullDescription (*task)); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (color) { - Text::color fg = Text::colorCode (t->getAttribute ("fg")); - Text::color bg = Text::colorCode (t->getAttribute ("bg")); - autoColorize (*t, fg, bg, conf); + Text::color fg = Text::colorCode (task->get ("fg")); + Text::color bg = Text::colorCode (task->get ("bg")); + autoColorize (*task, fg, bg); started.setRowFg (row, fg); started.setRowBg (row, bg); } @@ -1530,26 +1272,46 @@ std::string renderMonths ( int firstMonth, int firstYear, const Date& today, - std::vector <T>& all, - Config& conf, + std::vector <Task>& all, int monthsPerLine) { Table table; - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); + + // What day of the week does the user consider the first? + int weekStart = Date::dayOfWeek (context.config.get ("weekstart", "Sunday")); + if (weekStart != 0 && weekStart != 1) + throw std::string ("The 'weekstart' configuration variable may " + "only contain 'Sunday' or 'Monday'."); // Build table for the number of months to be displayed. for (int i = 0 ; i < (monthsPerLine * 8); i += 8) { - table.addColumn (" "); - table.addColumn ("Su"); - table.addColumn ("Mo"); - table.addColumn ("Tu"); - table.addColumn ("We"); - table.addColumn ("Th"); - table.addColumn ("Fr"); - table.addColumn ("Sa"); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (weekStart == 1) + { + table.addColumn (" "); + table.addColumn ("Mo"); + table.addColumn ("Tu"); + table.addColumn ("We"); + table.addColumn ("Th"); + table.addColumn ("Fr"); + table.addColumn ("Sa"); + table.addColumn ("Su"); + } + else + { + table.addColumn (" "); + table.addColumn ("Su"); + table.addColumn ("Mo"); + table.addColumn ("Tu"); + table.addColumn ("We"); + table.addColumn ("Th"); + table.addColumn ("Fr"); + table.addColumn ("Sa"); + } + + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { table.setColumnUnderline (i + 1); table.setColumnUnderline (i + 2); @@ -1570,6 +1332,9 @@ std::string renderMonths ( table.setColumnJustification (i + 5, Table::right); table.setColumnJustification (i + 6, Table::right); table.setColumnJustification (i + 7, Table::right); + + // This creates a nice gap between the months. + table.setColumnWidth (i + 0, 4); } // At most, we need 6 rows. @@ -1604,44 +1369,61 @@ std::string renderMonths ( int row = 0; // Loop through months to be added on this line. - for (int c = 0; c < monthsPerLine ; c++) + for (int mpl = 0; mpl < monthsPerLine ; mpl++) { // Reset row counter for subsequent months - if (c != 0) + if (mpl != 0) row = 0; // Loop through days in month and add to table. - for (int d = 1; d <= daysInMonth.at (c); ++d) + for (int d = 1; d <= daysInMonth.at (mpl); ++d) { - Date temp (months.at (c), d, years.at (c)); + Date temp (months.at (mpl), d, years.at (mpl)); int dow = temp.dayOfWeek (); - int thisCol = dow + 1 + (8 * c); + int woy = temp.weekOfYear (weekStart); + + if (context.config.get ("displayweeknumber", true)) + table.addCell (row, (8 * mpl), woy); + + // Calculate column id. + int thisCol = dow + // 0 = Sunday + (weekStart == 1 ? 0 : 1) + // Offset for weekStart + (8 * mpl); // Columns in 1 month + + if (thisCol == (8 * mpl)) + thisCol += 7; table.addCell (row, thisCol, d); - if ((conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) && + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && today.day () == d && - today.month () == months.at (c) && - today.year () == years.at (c)) + today.month () == months.at (mpl) && + today.year () == years.at (mpl)) table.setCellFg (row, thisCol, Text::cyan); - std::vector <T>::iterator it; - for (it = all.begin (); it != all.end (); ++it) + foreach (task, all) { - Date due (::atoi (it->getAttribute ("due").c_str ())); - - if ((conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) && - due.day () == d && - due.month () == months.at (c) && - due.year () == years.at (c)) + if (task->getStatus () == Task::pending && + task->has ("due")) { - table.setCellFg (row, thisCol, Text::black); - table.setCellBg (row, thisCol, due < today ? Text::on_red : Text::on_yellow); + Date due (::atoi (task->get ("due").c_str ())); + + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + due.day () == d && + due.month () == months.at (mpl) && + due.year () == years.at (mpl)) + { + table.setCellFg (row, thisCol, Text::black); + table.setCellBg (row, thisCol, due < today ? Text::on_red : Text::on_yellow); + } } } // Check for end of week, and... - if (dow == 6 && d < daysInMonth.at (c)) + int eow = 6; + if (weekStart == 1) + eow = 0; + if (dow == eow && d < daysInMonth.at (mpl)) row++; } } @@ -1650,59 +1432,109 @@ std::string renderMonths ( } //////////////////////////////////////////////////////////////////////////////// -std::string handleReportCalendar (TDB& tdb, T& task, Config& conf) +std::string handleReportCalendar () { - std::stringstream out; - - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - - // Each month requires 23 text columns width. See how many will actually + // Each month requires 28 text columns width. See how many will actually // fit. But if a preference is specified, and it fits, use it. - int preferredMonthsPerLine = (conf.get (std::string ("monthsperline"), 0)); - int monthsThatFit = width / 23; + int width = context.getWidth (); + int preferredMonthsPerLine = (context.config.get (std::string ("monthsperline"), 0)); + int monthsThatFit = width / 26; int monthsPerLine = monthsThatFit; if (preferredMonthsPerLine != 0 && preferredMonthsPerLine < monthsThatFit) monthsPerLine = preferredMonthsPerLine; - // Load all the pending tasks. - std::vector <T> pending; - tdb.allPendingT (pending); - handleRecurrence (tdb, pending); - filter (pending, task); - - // Find the oldest pending due date. - Date oldest; - Date newest; - std::vector <T>::iterator it; - for (it = pending.begin (); it != pending.end (); ++it) - { - if (it->getAttribute ("due") != "") - { - Date d (::atoi (it->getAttribute ("due").c_str ())); + // Get all the tasks. + std::vector <Task> tasks; + Filter filter; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.loadPending (tasks, filter); + context.tdb.commit (); + context.tdb.unlock (); - if (d < oldest) oldest = d; - if (d > newest) newest = d; + Date today; + bool getpendingdate = false; + int monthsToDisplay = 1; + int mFrom = today.month (); + int yFrom = today.year (); + int mTo; + int yTo; + + // Determine what to do + int numberOfArgs = context.args.size(); + + if (numberOfArgs == 1 ) { + // task cal + monthsToDisplay = monthsPerLine; + mFrom = today.month(); + yFrom = today.year(); + } + else if (numberOfArgs == 2 ) { + if (context.args[1] == "y") { + // task cal y + monthsToDisplay = 12; + mFrom = today.month(); + yFrom = today.year(); } + else if (context.args[1] == "due") { + // task cal due + monthsToDisplay = monthsPerLine; + getpendingdate = true; + } + else { + // task cal 2010 + monthsToDisplay = 12; + mFrom = 1; + yFrom = ::atoi( context.args[1].data()); + } + } + else if (numberOfArgs == 3 ) { + if (context.args[2] == "y") { + // task cal due y + monthsToDisplay = 12; + getpendingdate = true; + } + else { + // task cal 8 2010 + monthsToDisplay = monthsPerLine; + mFrom = ::atoi( context.args[1].data()); + yFrom = ::atoi( context.args[2].data()); + } + } + else if (numberOfArgs == 4 ) { + // task cal 8 2010 y + monthsToDisplay = 12; + mFrom = ::atoi( context.args[1].data()); + yFrom = ::atoi( context.args[2].data()); } - // Iterate from oldest due month, year to newest month, year. - Date today; - int mFrom = oldest.month (); - int yFrom = oldest.year (); + if (getpendingdate == true) { + // Find the oldest pending due date. + Date oldest (12,31,2037); + foreach (task, tasks) + { + if (task->getStatus () == Task::pending) + { + if (task->has ("due")) + { + Date d (::atoi (task->get ("due").c_str ())); + if (d < oldest) oldest = d; + } + } + } + mFrom = oldest.month(); + yFrom = oldest.year(); + } - int mTo = newest.month (); - int yTo = newest.year (); + mTo = mFrom + monthsToDisplay - 1; + yTo = yFrom; + if (mTo > 12) { + mTo -=12; + yTo++; + } + std::stringstream out; out << std::endl; std::string output; @@ -1715,14 +1547,31 @@ std::string handleReportCalendar (TDB& tdb, T& task, Config& conf) for (int i = 0 ; i < monthsPerLine ; i++) { std::string month = Date::monthName (nextM); - int left = (18 - month.length ()) / 2 + 1; - int right = 18 - left - month.length (); - out << std::setw (left) << ' ' + // 12345678901234567890123456 = 26 chars wide + // ^^ = center + // <-------> = 13 - (month.length / 2) + 1 + // <------> = 26 - above + // +--------------------------+ + // | July 2009 | + // | Mo Tu We Th Fr Sa Su | + // | 27 1 2 3 4 5 | + // | 28 6 7 8 9 10 11 12 | + // | 29 13 14 15 16 17 18 19 | + // | 30 20 21 22 23 24 25 26 | + // | 31 27 28 29 30 31 | + // +--------------------------+ + + int totalWidth = 26; + int labelWidth = month.length () + 5; // 5 = " 2009" + int leftGap = (totalWidth / 2) - (labelWidth / 2); + int rightGap = totalWidth - leftGap - labelWidth; + + out << std::setw (leftGap) << ' ' << month << ' ' << nextY - << std::setw (right) << ' '; + << std::setw (rightGap) << ' '; if (++nextM > 12) { @@ -1732,8 +1581,8 @@ std::string handleReportCalendar (TDB& tdb, T& task, Config& conf) } out << std::endl - << optionalBlankLine (conf) - << renderMonths (mFrom, yFrom, today, pending, conf, monthsPerLine) + << optionalBlankLine () + << renderMonths (mFrom, yFrom, today, tasks, monthsPerLine) << std::endl; mFrom += monthsPerLine; @@ -1744,7 +1593,7 @@ std::string handleReportCalendar (TDB& tdb, T& task, Config& conf) } } - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) out << "Legend: " << Text::colorize (Text::cyan, Text::nocolor, "today") << ", " @@ -1752,288 +1601,48 @@ std::string handleReportCalendar (TDB& tdb, T& task, Config& conf) << ", " << Text::colorize (Text::black, Text::on_red, "overdue") << "." - << optionalBlankLine (conf) - << std::endl; - - return out.str (); -} - -//////////////////////////////////////////////////////////////////////////////// -std::string handleReportActive (TDB& tdb, T& task, Config& conf) -{ - std::stringstream out; - - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - - // Get all the tasks. - std::vector <T> tasks; - tdb.pendingT (tasks); - filter (tasks, task); - - initializeColorRules (conf); - - // Create a table for output. - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - table.addColumn ("ID"); - table.addColumn ("Project"); - table.addColumn ("Pri"); - table.addColumn ("Due"); - table.addColumn ("Description"); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - table.setColumnUnderline (2); - table.setColumnUnderline (3); - table.setColumnUnderline (4); - } - else - table.setTableDashedUnderline (); - - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::minimum); - table.setColumnWidth (2, Table::minimum); - table.setColumnWidth (3, Table::minimum); - table.setColumnWidth (4, Table::flexible); - - table.setColumnJustification (0, Table::right); - table.setColumnJustification (3, Table::right); - - table.sortOn (3, Table::ascendingDate); - table.sortOn (2, Table::descendingPriority); - table.sortOn (1, Table::ascendingCharacter); - - // Iterate over each task, and apply selection criteria. - for (unsigned int i = 0; i < tasks.size (); ++i) - { - T refTask (tasks[i]); - if (refTask.getAttribute ("start") != "") - { - Date now; - bool imminent = false; - bool overdue = false; - std::string due = refTask.getAttribute ("due"); - if (due.length ()) - { - switch (getDueState (due)) - { - case 2: overdue = true; break; - case 1: imminent = true; break; - case 0: - default: break; - } - - Date dt (::atoi (due.c_str ())); - due = dt.toString (conf.get ("dateformat", "m/d/Y")); - } - - // All criteria match, so add refTask to the output table. - int row = table.addRow (); - table.addCell (row, 0, refTask.getId ()); - table.addCell (row, 1, refTask.getAttribute ("project")); - table.addCell (row, 2, refTask.getAttribute ("priority")); - table.addCell (row, 3, due); - - std::string description = refTask.getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - refTask.getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } - - table.addCell (row, 4, description); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (refTask.getAttribute ("fg")); - Text::color bg = Text::colorCode (refTask.getAttribute ("bg")); - autoColorize (refTask, fg, bg, conf); - table.setRowFg (row, fg); - table.setRowBg (row, bg); - - if (fg == Text::nocolor) - { - if (overdue) - table.setCellFg (row, 3, Text::colorCode (conf.get ("color.overdue", "red"))); - else if (imminent) - table.setCellFg (row, 3, Text::colorCode (conf.get ("color.due", "yellow"))); - } - } - } - } - - if (table.rowCount ()) - out << optionalBlankLine (conf) - << table.render () - << optionalBlankLine (conf) - << table.rowCount () - << (table.rowCount () == 1 ? " task" : " tasks") + << optionalBlankLine () << std::endl; - else - out << "No active tasks." << std::endl; return out.str (); } //////////////////////////////////////////////////////////////////////////////// -std::string handleReportOverdue (TDB& tdb, T& task, Config& conf) +std::string handleReportStats () { std::stringstream out; - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - - // Get all the tasks. - std::vector <T> tasks; - tdb.pendingT (tasks); - filter (tasks, task); + // Go get the file sizes. + size_t dataSize = 0; - initializeColorRules (conf); + struct stat s; + std::string location = expandPath (context.config.get ("data.location")); + std::string file = location + "/pending.data"; + if (!stat (file.c_str (), &s)) + dataSize += s.st_size; - // Create a table for output. - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - table.addColumn ("ID"); - table.addColumn ("Project"); - table.addColumn ("Pri"); - table.addColumn ("Due"); - table.addColumn ("Description"); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - table.setColumnUnderline (0); - table.setColumnUnderline (1); - table.setColumnUnderline (2); - table.setColumnUnderline (3); - table.setColumnUnderline (4); - } - else - table.setTableDashedUnderline (); + file = location + "/completed.data"; + if (!stat (file.c_str (), &s)) + dataSize += s.st_size; - table.setColumnWidth (0, Table::minimum); - table.setColumnWidth (1, Table::minimum); - table.setColumnWidth (2, Table::minimum); - table.setColumnWidth (3, Table::minimum); - table.setColumnWidth (4, Table::flexible); + file = location + "/undo.data"; + if (!stat (file.c_str (), &s)) + dataSize += s.st_size; - table.setColumnJustification (0, Table::right); - table.setColumnJustification (3, Table::right); - - table.sortOn (3, Table::ascendingDate); - table.sortOn (2, Table::descendingPriority); - table.sortOn (1, Table::ascendingCharacter); - - Date now; - - // Iterate over each task, and apply selection criteria. - for (unsigned int i = 0; i < tasks.size (); ++i) - { - T refTask (tasks[i]); - std::string due; - if ((due = refTask.getAttribute ("due")) != "") - { - if (due.length ()) - { - Date dt (::atoi (due.c_str ())); - due = dt.toString (conf.get ("dateformat", "m/d/Y")); - - // If overdue. - if (dt < now) - { - // All criteria match, so add refTask to the output table. - int row = table.addRow (); - table.addCell (row, 0, refTask.getId ()); - table.addCell (row, 1, refTask.getAttribute ("project")); - table.addCell (row, 2, refTask.getAttribute ("priority")); - table.addCell (row, 3, due); - - std::string description = refTask.getDescription (); - std::string when; - std::map <time_t, std::string> annotations; - refTask.getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; - } - - table.addCell (row, 4, description); - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (refTask.getAttribute ("fg")); - Text::color bg = Text::colorCode (refTask.getAttribute ("bg")); - autoColorize (refTask, fg, bg, conf); - table.setRowFg (row, fg); - table.setRowBg (row, bg); - - if (fg == Text::nocolor) - table.setCellFg (row, 3, Text::red); - } - } - } - } - } - - if (table.rowCount ()) - out << optionalBlankLine (conf) - << table.render () - << optionalBlankLine (conf) - << table.rowCount () - << (table.rowCount () == 1 ? " task" : " tasks") - << std::endl; - else - out << "No overdue tasks." << std::endl; - - return out.str (); -} - -//////////////////////////////////////////////////////////////////////////////// -std::string handleReportStats (TDB& tdb, T& task, Config& conf) -{ - std::stringstream out; - - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif + std::vector <std::string> undo; + slurp (file, undo, false); + int undoCount = 0; + foreach (tx, undo) + if (tx->substr (0, 3) == "---") + ++undoCount; // Get all the tasks. - std::vector <T> tasks; - tdb.allT (tasks); - filter (tasks, task); + std::vector <Task> tasks; + context.tdb.lock (context.config.get ("locking", true)); + handleRecurrence (); + context.tdb.load (tasks, context.filter); + context.tdb.commit (); + context.tdb.unlock (); Date now; time_t earliest = time (NULL); @@ -2042,6 +1651,7 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) int deletedT = 0; int pendingT = 0; int completedT = 0; + int waitingT = 0; int taggedT = 0; int annotationsT = 0; int recurringT = 0; @@ -2050,31 +1660,34 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) std::map <std::string, int> allTags; std::map <std::string, int> allProjects; - std::vector <T>::iterator it; + std::vector <Task>::iterator it; for (it = tasks.begin (); it != tasks.end (); ++it) { ++totalT; - if (it->getStatus () == T::deleted) ++deletedT; - if (it->getStatus () == T::pending) ++pendingT; - if (it->getStatus () == T::completed) ++completedT; - if (it->getStatus () == T::recurring) ++recurringT; + if (it->getStatus () == Task::deleted) ++deletedT; + if (it->getStatus () == Task::pending) ++pendingT; + if (it->getStatus () == Task::completed) ++completedT; + if (it->getStatus () == Task::recurring) ++recurringT; + if (it->getStatus () == Task::waiting) ++waitingT; - time_t entry = ::atoi (it->getAttribute ("entry").c_str ()); + time_t entry = ::atoi (it->get ("entry").c_str ()); if (entry < earliest) earliest = entry; if (entry > latest) latest = entry; - if (it->getStatus () == T::completed) + if (it->getStatus () == Task::completed) { - time_t end = ::atoi (it->getAttribute ("end").c_str ()); + time_t end = ::atoi (it->get ("end").c_str ()); daysPending += (end - entry) / 86400.0; } - if (it->getStatus () == T::pending) + if (it->getStatus () == Task::pending) daysPending += (now - entry) / 86400.0; - descLength += it->getDescription ().length (); + descLength += it->get ("description").length (); - annotationsT += it->getAnnotationCount (); + std::vector <Att> annotations; + it->getAnnotations (annotations); + annotationsT += annotations.size (); std::vector <std::string> tags; it->getTags (tags); @@ -2083,19 +1696,21 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) foreach (t, tags) allTags[*t] = 0; - std::string project = it->getAttribute ("project"); + std::string project = it->get ("project"); if (project != "") allProjects[project] = 0; } // Create a table for output. Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); + table.setTableWidth (context.getWidth ()); + table.setTableIntraPadding (2); + table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); table.addColumn ("Category"); table.addColumn ("Data"); - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) + if ((context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false)) && + context.config.get (std::string ("fontunderline"), "true")) { table.setColumnUnderline (0); table.setColumnUnderline (1); @@ -2114,6 +1729,10 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) table.addCell (row, 1, pendingT); row = table.addRow (); + table.addCell (row, 0, "Waiting"); + table.addCell (row, 1, waitingT); + + row = table.addRow (); table.addCell (row, 0, "Recurring"); table.addCell (row, 1, recurringT); @@ -2141,6 +1760,14 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) table.addCell (row, 0, "Projects"); table.addCell (row, 1, (int)allProjects.size ()); + row = table.addRow (); + table.addCell (row, 0, "Data size"); + table.addCell (row, 1, formatBytes (dataSize)); + + row = table.addRow (); + table.addCell (row, 0, "Undo transactions"); + table.addCell (row, 1, undoCount); + if (totalT) { row = table.addRow (); @@ -2156,12 +1783,12 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) Date e (earliest); row = table.addRow (); table.addCell (row, 0, "Oldest task"); - table.addCell (row, 1, e.toString (conf.get ("dateformat", "m/d/Y"))); + table.addCell (row, 1, e.toString (context.config.get ("dateformat", "m/d/Y"))); Date l (latest); row = table.addRow (); table.addCell (row, 0, "Newest task"); - table.addCell (row, 1, l.toString (conf.get ("dateformat", "m/d/Y"))); + table.addCell (row, 1, l.toString (context.config.get ("dateformat", "m/d/Y"))); row = table.addRow (); table.addCell (row, 0, "Task used for"); @@ -2205,667 +1832,211 @@ std::string handleReportStats (TDB& tdb, T& task, Config& conf) table.addCell (row, 1, value.str ()); } - out << optionalBlankLine (conf) + out << optionalBlankLine () << table.render () - << optionalBlankLine (conf); + << optionalBlankLine (); return out.str (); } //////////////////////////////////////////////////////////////////////////////// -void gatherNextTasks ( - const TDB& tdb, - T& task, - Config& conf, - std::vector <T>& pending, - std::vector <int>& all) +void gatherNextTasks (std::vector <Task>& tasks) { // For counting tasks by project. std::map <std::string, int> countByProject; std::map <int, bool> matching; - + std::vector <Task> filtered; Date now; - // How many items per project? Default 3. - int limit = conf.get ("next", 3); + // How many items per project? Default 2. + int limit = context.config.get ("next", 2); // due:< 1wk, pri:* - for (unsigned int i = 0; i < pending.size (); ++i) + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + if (task->has ("due")) { - std::string due = pending[i].getAttribute ("due"); - if (due != "") + Date d (::atoi (task->get ("due").c_str ())); + if (d < now + (7 * 24 * 60 * 60)) // if due:< 1wk { - Date d (::atoi (due.c_str ())); - if (d < now + (7 * 24 * 60 * 60)) // if due:< 1wk + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) - { - ++countByProject[project]; - matching[i] = true; - } + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } } } } // due:*, pri:H - for (unsigned int i = 0; i < pending.size (); ++i) + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + if (task->has ("due")) { - std::string due = pending[i].getAttribute ("due"); - if (due != "") - { - std::string priority = pending[i].getAttribute ("priority"); - if (priority == "H") - { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) - { - ++countByProject[project]; - matching[i] = true; - } - } - } - } - } - - // pri:H - for (unsigned int i = 0; i < pending.size (); ++i) - { - if (pending[i].getStatus () == T::pending) - { - std::string priority = pending[i].getAttribute ("priority"); + std::string priority = task->get ("priority"); if (priority == "H") { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { ++countByProject[project]; - matching[i] = true; + matching[task->id] = true; + filtered.push_back (*task); } } } } - // due:*, pri:M - for (unsigned int i = 0; i < pending.size (); ++i) + // pri:H + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + std::string priority = task->get ("priority"); + if (priority == "H") { - std::string due = pending[i].getAttribute ("due"); - if (due != "") + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - std::string priority = pending[i].getAttribute ("priority"); - if (priority == "M") - { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) - { - ++countByProject[project]; - matching[i] = true; - } - } + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } } } - // pri:M - for (unsigned int i = 0; i < pending.size (); ++i) + // due:*, pri:M + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + if (task->has ("due")) { - std::string priority = pending[i].getAttribute ("priority"); + std::string priority = task->get ("priority"); if (priority == "M") { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { ++countByProject[project]; - matching[i] = true; + matching[task->id] = true; + filtered.push_back (*task); } } } } - // due:*, pri:L - for (unsigned int i = 0; i < pending.size (); ++i) + // pri:M + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + std::string priority = task->get ("priority"); + if (priority == "M") { - std::string due = pending[i].getAttribute ("due"); - if (due != "") + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - std::string priority = pending[i].getAttribute ("priority"); - if (priority == "L") - { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) - { - ++countByProject[project]; - matching[i] = true; - } - } + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } } } - // pri:L - for (unsigned int i = 0; i < pending.size (); ++i) + // due:*, pri:L + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + if (task->has ("due")) { - std::string priority = pending[i].getAttribute ("priority"); + std::string priority = task->get ("priority"); if (priority == "L") { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { ++countByProject[project]; - matching[i] = true; + matching[task->id] = true; + filtered.push_back (*task); } } } } - // due:, pri: - for (unsigned int i = 0; i < pending.size (); ++i) + // pri:L + foreach (task, tasks) { - if (pending[i].getStatus () == T::pending) + std::string priority = task->get ("priority"); + if (priority == "L") { - std::string due = pending[i].getAttribute ("due"); - if (due == "") + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - std::string priority = pending[i].getAttribute ("priority"); - if (priority == "") - { - std::string project = pending[i].getAttribute ("project"); - if (countByProject[project] < limit && matching.find (i) == matching.end ()) - { - ++countByProject[project]; - matching[i] = true; - } - } + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } } } - // Convert map to vector. - foreach (i, matching) - all.push_back (i->first); -} - -//////////////////////////////////////////////////////////////////////////////// -// This report will eventually become the one report that many others morph into -// via the .taskrc file. -std::string handleCustomReport ( - TDB& tdb, - T& task, - Config& conf, - const std::string& report) -{ - // Determine window size, and set table accordingly. - int width = conf.get ("defaultwidth", (int) 80); -#ifdef HAVE_LIBNCURSES - if (conf.get ("curses", true)) - { - WINDOW* w = initscr (); - width = w->_maxx + 1; - endwin (); - } -#endif - - // Load report configuration. - std::string columnList = conf.get ("report." + report + ".columns"); - std::vector <std::string> columns; - split (columns, columnList, ','); - validReportColumns (columns); - - std::string labelList = conf.get ("report." + report + ".labels"); - std::vector <std::string> labels; - split (labels, labelList, ','); - - if (columns.size () != labels.size () && labels.size () != 0) - throw std::string ("There are a different number of columns than labels ") + - "for report '" + report + "'. Please correct this."; - - std::map <std::string, std::string> columnLabels; - if (labels.size ()) - for (unsigned int i = 0; i < columns.size (); ++i) - columnLabels[columns[i]] = labels[i]; - - std::string sortList = conf.get ("report." + report + ".sort"); - std::vector <std::string> sortOrder; - split (sortOrder, sortList, ','); - validSortColumns (columns, sortOrder); - - std::string filterList = conf.get ("report." + report + ".filter"); - std::vector <std::string> filterArgs; - split (filterArgs, filterList, ' '); - - // Load all pending tasks. - std::vector <T> tasks; - tdb.allPendingT (tasks); - handleRecurrence (tdb, tasks); - - // Apply filters. - { - std::string ignore; - T filterTask; - parse (filterArgs, ignore, filterTask, conf); - - filter (tasks, filterTask); // Filter from custom report - filter (tasks, task); // Filter from command line - } - - // Initialize colorization for subsequent auto colorization. - initializeColorRules (conf); - - Table table; - table.setTableWidth (width); - table.setDateFormat (conf.get ("dateformat", "m/d/Y")); - - for (unsigned int i = 0; i < tasks.size (); ++i) - table.addRow (); - - int columnCount = 0; - int dueColumn = -1; - foreach (col, columns) + // due:, pri: + foreach (task, tasks) { - // Add each column individually. - if (*col == "id") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "ID"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - for (unsigned int row = 0; row < tasks.size(); ++row) - table.addCell (row, columnCount, tasks[row].getId ()); - } - - else if (*col == "uuid") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "UUID"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::left); - - for (unsigned int row = 0; row < tasks.size(); ++row) - table.addCell (row, columnCount, tasks[row].getUUID ()); - } - - else if (*col == "project") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Project"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::left); - - for (unsigned int row = 0; row < tasks.size(); ++row) - table.addCell (row, columnCount, tasks[row].getAttribute ("project")); - } - - else if (*col == "priority") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Pri"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::left); - - for (unsigned int row = 0; row < tasks.size(); ++row) - table.addCell (row, columnCount, tasks[row].getAttribute ("priority")); - } - - else if (*col == "entry") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Added"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - std::string entered; - for (unsigned int row = 0; row < tasks.size(); ++row) - { - entered = tasks[row].getAttribute ("entry"); - if (entered.length ()) - { - Date dt (::atoi (entered.c_str ())); - entered = dt.toString (conf.get ("dateformat", "m/d/Y")); - table.addCell (row, columnCount, entered); - } - } - } - - else if (*col == "start") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Started"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - std::string started; - for (unsigned int row = 0; row < tasks.size(); ++row) - { - started = tasks[row].getAttribute ("start"); - if (started.length ()) - { - Date dt (::atoi (started.c_str ())); - started = dt.toString (conf.get ("dateformat", "m/d/Y")); - table.addCell (row, columnCount, started); - } - } - } - - else if (*col == "due") + if (task->has ("due")) { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Due"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - std::string due; - for (unsigned int row = 0; row < tasks.size(); ++row) + std::string priority = task->get ("priority"); + if (priority == "") { - due = tasks[row].getAttribute ("due"); - if (due.length ()) + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - Date dt (::atoi (due.c_str ())); - due = dt.toString (conf.get ("dateformat", "m/d/Y")); - table.addCell (row, columnCount, due); - } - } - - dueColumn = columnCount; - } - - else if (*col == "age") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Age"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - std::string created; - std::string age; - Date now; - for (unsigned int row = 0; row < tasks.size(); ++row) - { - created = tasks[row].getAttribute ("entry"); - if (created.length ()) - { - Date dt (::atoi (created.c_str ())); - formatTimeDeltaDays (age, (time_t) (now - dt)); - table.addCell (row, columnCount, age); - } - } - } - - else if (*col == "active") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Active"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::left); - - for (unsigned int row = 0; row < tasks.size(); ++row) - if (tasks[row].getAttribute ("start") != "") - table.addCell (row, columnCount, "*"); - } - - else if (*col == "tags") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Tags"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::left); - - std::vector <std::string> all; - std::string tags; - for (unsigned int row = 0; row < tasks.size(); ++row) - { - tasks[row].getTags (all); - join (tags, " ", all); - table.addCell (row, columnCount, tags); - } - } - - else if (*col == "description_only") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Description"); - table.setColumnWidth (columnCount, Table::flexible); - table.setColumnJustification (columnCount, Table::left); - - for (unsigned int row = 0; row < tasks.size(); ++row) - table.addCell (row, columnCount, tasks[row].getDescription ()); - } - - else if (*col == "description") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Description"); - table.setColumnWidth (columnCount, Table::flexible); - table.setColumnJustification (columnCount, Table::left); - - std::string description; - std::string when; - for (unsigned int row = 0; row < tasks.size(); ++row) - { - description = tasks[row].getDescription (); - std::map <time_t, std::string> annotations; - tasks[row].getAnnotations (annotations); - foreach (anno, annotations) - { - Date dt (anno->first); - when = dt.toString (conf.get ("dateformat", "m/d/Y")); - description += "\n" + when + " " + anno->second; + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } - - table.addCell (row, columnCount, description); } } - - else if (*col == "recur") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "Recur"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - for (unsigned int row = 0; row < tasks.size (); ++row) - table.addCell (row, columnCount, tasks[row].getAttribute ("recur")); - } - - else if (*col == "recurrence_indicator") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "R"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - for (unsigned int row = 0; row < tasks.size (); ++row) - table.addCell (row, columnCount, - tasks[row].getAttribute ("recur") != "" ? "R" : ""); - } - - else if (*col == "tag_indicator") - { - table.addColumn (columnLabels[*col] != "" ? columnLabels[*col] : "T"); - table.setColumnWidth (columnCount, Table::minimum); - table.setColumnJustification (columnCount, Table::right); - - for (unsigned int row = 0; row < tasks.size (); ++row) - table.addCell (row, columnCount, - tasks[row].getTagCount () ? "+" : ""); - } - - // Common to all columns. - // Add underline. - if (conf.get (std::string ("color"), true) || conf.get (std::string ("_forcecolor"), false)) - table.setColumnUnderline (columnCount); - else - table.setTableDashedUnderline (); - - ++columnCount; - } - - // Dynamically add sort criteria. - // Build a map of column names -> index. - std::map <std::string, unsigned int> columnIndex; - for (unsigned int c = 0; c < columns.size (); ++c) - columnIndex[columns[c]] = c; - - foreach (sortColumn, sortOrder) - { - // Separate column and direction. - std::string column = sortColumn->substr (0, sortColumn->length () - 1); - char direction = (*sortColumn)[sortColumn->length () - 1]; - - if (column == "id") - table.sortOn (columnIndex[column], - (direction == '+' ? - Table::ascendingNumeric : - Table::descendingNumeric)); - - else if (column == "priority") - table.sortOn (columnIndex[column], - (direction == '+' ? - Table::ascendingPriority : - Table::descendingPriority)); - - else if (column == "entry" || column == "start" || column == "due") - table.sortOn (columnIndex[column], - (direction == '+' ? - Table::ascendingDate : - Table::descendingDate)); - - else if (column == "recur") - table.sortOn (columnIndex[column], - (direction == '+' ? - Table::ascendingPeriod : - Table::descendingPeriod)); - - else - table.sortOn (columnIndex[column], - (direction == '+' ? - Table::ascendingCharacter : - Table::descendingCharacter)); } - // Now auto colorize all rows. - std::string due; - bool imminent; - bool overdue; - for (unsigned int row = 0; row < tasks.size (); ++row) + // Filler. + foreach (task, tasks) { - imminent = false; - overdue = false; - due = tasks[row].getAttribute ("due"); - if (due.length ()) + std::string project = task->get ("project"); + if (countByProject[project] < limit && matching.find (task->id) == matching.end ()) { - switch (getDueState (due)) - { - case 2: overdue = true; break; - case 1: imminent = true; break; - case 0: - default: break; - } - } - - if (conf.get ("color", true) || conf.get (std::string ("_forcecolor"), false)) - { - Text::color fg = Text::colorCode (tasks[row].getAttribute ("fg")); - Text::color bg = Text::colorCode (tasks[row].getAttribute ("bg")); - autoColorize (tasks[row], fg, bg, conf); - table.setRowFg (row, fg); - table.setRowBg (row, bg); - - if (fg == Text::nocolor) - { - if (dueColumn != -1) - { - if (overdue) - table.setCellFg (row, columnCount, Text::colorCode (conf.get ("color.overdue", "red"))); - else if (imminent) - table.setCellFg (row, columnCount, Text::colorCode (conf.get ("color.due", "yellow"))); - } - } + ++countByProject[project]; + matching[task->id] = true; + filtered.push_back (*task); } } - // Limit the number of rows according to the report definition. - int maximum = conf.get (std::string ("report.") + report + ".limit", (int)0); - - // If the custom report has a defined limit, then allow an override, which - // will show up as a single ID sequence. - if (conf.get (std::string ("report.") + report + ".limit", (int)0) != 0) - { - std::vector <int> sequence = task.getAllIds (); - if (sequence.size () == 1) - maximum = sequence[0]; - } - - std::stringstream out; - if (table.rowCount ()) - out << optionalBlankLine (conf) - << table.render (maximum) - << optionalBlankLine (conf) - << table.rowCount () - << (table.rowCount () == 1 ? " task" : " tasks") - << std::endl; - else - out << "No matches." - << std::endl; - - return out.str (); + tasks = filtered; } -//////////////////////////////////////////////////////////////////////////////// -void validReportColumns (const std::vector <std::string>& columns) +/////////////////////////////////////////////////////////////////////////////// +std::string getFullDescription (Task& task) { - std::vector <std::string> bad; - - std::vector <std::string>::const_iterator it; - for (it = columns.begin (); it != columns.end (); ++it) - if (*it != "id" && - *it != "uuid" && - *it != "project" && - *it != "priority" && - *it != "entry" && - *it != "start" && - *it != "due" && - *it != "age" && - *it != "active" && - *it != "tags" && - *it != "recur" && - *it != "recurrence_indicator" && - *it != "tag_indicator" && - *it != "description_only" && - *it != "description") - bad.push_back (*it); - - if (bad.size ()) + std::string desc = task.get ("description"); + + std::vector <Att> annotations; + task.getAnnotations (annotations); + foreach (anno, annotations) { - std::string error; - join (error, ", ", bad); - throw std::string ("Unrecognized column name: ") + error; + Date dt (::atoi (anno->name ().substr (11, std::string::npos).c_str ())); + std::string when = dt.toString (context.config.get ("dateformat", "m/d/Y")); + desc += "\n" + when + " " + anno->value (); } + + return desc; } -//////////////////////////////////////////////////////////////////////////////// -void validSortColumns ( - const std::vector <std::string>& columns, - const std::vector <std::string>& sortColumns) +/////////////////////////////////////////////////////////////////////////////// +std::string getDueDate (Task& task) { - std::vector <std::string> bad; - std::vector <std::string>::const_iterator sc; - for (sc = sortColumns.begin (); sc != sortColumns.end (); ++sc) + std::string due = task.get ("due"); + if (due.length ()) { - std::vector <std::string>::const_iterator co; - for (co = columns.begin (); co != columns.end (); ++co) - if (sc->substr (0, sc->length () - 1) == *co) - break; - - if (co == columns.end ()) - bad.push_back (*sc); + Date d (::atoi (due.c_str ())); + due = d.toString (context.config.get ("dateformat", "m/d/Y")); } - if (bad.size ()) - { - std::string error; - join (error, ", ", bad); - throw std::string ("Sort column is not part of the report: ") + error; - } + return due; } -//////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// src/report.cpp @@ -26,11 +26,14 @@ //////////////////////////////////////////////////////////////////////////////// #include <iostream> #include <stdlib.h> -#include "Config.h" +#include "Context.h" #include "Table.h" #include "Date.h" -#include "T.h" -#include "task.h" +#include "text.h" +#include "util.h" +#include "main.h" + +extern Context context; static std::map <std::string, Text::color> gsFg; static std::map <std::string, Text::color> gsBg; @@ -62,17 +65,17 @@ static void parseColorRule ( } //////////////////////////////////////////////////////////////////////////////// -void initializeColorRules (Config& conf) +void initializeColorRules () { std::vector <std::string> ruleNames; - conf.all (ruleNames); + context.config.all (ruleNames); foreach (it, ruleNames) { if (it->substr (0, 6) == "color.") { Text::color fg; Text::color bg; - parseColorRule (conf.get (*it), fg, bg); + parseColorRule (context.config.get (*it), fg, bg); gsFg[*it] = fg; gsBg[*it] = bg; } @@ -81,10 +84,9 @@ void initializeColorRules (Config& conf) //////////////////////////////////////////////////////////////////////////////// void autoColorize ( - T& task, + Task& task, Text::color& fg, - Text::color& bg, - Config& conf) + Text::color& bg) { // Note: fg, bg already contain colors specifically assigned via command. // Note: These rules form a hierarchy - the last rule is King. @@ -93,9 +95,7 @@ void autoColorize ( if (gsFg["color.tagged"] != Text::nocolor || gsBg["color.tagged"] != Text::nocolor) { - std::vector <std::string> tags; - task.getTags (tags); - if (tags.size ()) + if (task.getTagCount ()) { fg = gsFg["color.tagged"]; bg = gsBg["color.tagged"]; @@ -106,7 +106,7 @@ void autoColorize ( if (gsFg["color.pri.L"] != Text::nocolor || gsBg["color.pri.L"] != Text::nocolor) { - if (task.getAttribute ("priority") == "L") + if (task.get ("priority") == "L") { fg = gsFg["color.pri.L"]; bg = gsBg["color.pri.L"]; @@ -117,7 +117,7 @@ void autoColorize ( if (gsFg["color.pri.M"] != Text::nocolor || gsBg["color.pri.M"] != Text::nocolor) { - if (task.getAttribute ("priority") == "M") + if (task.get ("priority") == "M") { fg = gsFg["color.pri.M"]; bg = gsBg["color.pri.M"]; @@ -128,7 +128,7 @@ void autoColorize ( if (gsFg["color.pri.H"] != Text::nocolor || gsBg["color.pri.H"] != Text::nocolor) { - if (task.getAttribute ("priority") == "H") + if (task.get ("priority") == "H") { fg = gsFg["color.pri.H"]; bg = gsBg["color.pri.H"]; @@ -139,7 +139,7 @@ void autoColorize ( if (gsFg["color.pri.none"] != Text::nocolor || gsBg["color.pri.none"] != Text::nocolor) { - if (task.getAttribute ("priority") == "") + if (task.get ("priority") == "") { fg = gsFg["color.pri.none"]; bg = gsBg["color.pri.none"]; @@ -150,7 +150,7 @@ void autoColorize ( if (gsFg["color.active"] != Text::nocolor || gsBg["color.active"] != Text::nocolor) { - if (task.getAttribute ("start") != "") + if (task.has ("start")) { fg = gsFg["color.active"]; bg = gsBg["color.active"]; @@ -178,7 +178,7 @@ void autoColorize ( if (it->first.substr (0, 14) == "color.project.") { std::string value = it->first.substr (14, std::string::npos); - if (task.getAttribute ("project") == value) + if (task.get ("project") == value) { fg = gsFg[it->first]; bg = gsBg[it->first]; @@ -192,7 +192,7 @@ void autoColorize ( if (it->first.substr (0, 14) == "color.keyword.") { std::string value = lowerCase (it->first.substr (14, std::string::npos)); - std::string desc = lowerCase (task.getDescription ()); + std::string desc = lowerCase (task.get ("description")); if (desc.find (value) != std::string::npos) { fg = gsFg[it->first]; @@ -202,25 +202,24 @@ void autoColorize ( } // Colorization of the due and overdue. - std::string due = task.getAttribute ("due"); - if (due != "") + if (task.has ("due")) { - Date dueDate (::atoi (due.c_str ())); - Date now; - Date then (now + conf.get ("due", 7) * 86400); - - // Overdue - if (dueDate < now) + std::string due = task.get ("due"); + switch (getDueState (due)) { + case 1: // imminent + fg = gsFg["color.due"]; + bg = gsBg["color.due"]; + break; + + case 2: // overdue fg = gsFg["color.overdue"]; bg = gsBg["color.overdue"]; - } + break; - // Imminent - else if (dueDate < then) - { - fg = gsFg["color.due"]; - bg = gsBg["color.due"]; + case 0: // not due at all + default: + break; } } @@ -228,7 +227,7 @@ void autoColorize ( if (gsFg["color.recurring"] != Text::nocolor || gsBg["color.recurring"] != Text::nocolor) { - if (task.getAttribute ("recur") != "") + if (task.has ("recur")) { fg = gsFg["color.recurring"]; bg = gsBg["color.recurring"]; @@ -237,4 +236,64 @@ void autoColorize ( } //////////////////////////////////////////////////////////////////////////////// +std::string colorizeHeader (const std::string& input) +{ + if (gsFg["color.header"] != Text::nocolor || + gsBg["color.header"] != Text::nocolor) + { + return Text::colorize ( + gsFg["color.header"], + gsBg["color.header"], + input); + } + + return input; +} + +//////////////////////////////////////////////////////////////////////////////// +std::string colorizeMessage (const std::string& input) +{ + if (gsFg["color.message"] != Text::nocolor || + gsBg["color.message"] != Text::nocolor) + { + return Text::colorize ( + gsFg["color.message"], + gsBg["color.message"], + input); + } + + return input; +} + +//////////////////////////////////////////////////////////////////////////////// +std::string colorizeFootnote (const std::string& input) +{ + if (gsFg["color.footnote"] != Text::nocolor || + gsBg["color.footnote"] != Text::nocolor) + { + return Text::colorize ( + gsFg["color.footnote"], + gsBg["color.footnote"], + input); + } + + return input; +} + +//////////////////////////////////////////////////////////////////////////////// +std::string colorizeDebug (const std::string& input) +{ + if (gsFg["color.debug"] != Text::nocolor || + gsBg["color.debug"] != Text::nocolor) + { + return Text::colorize ( + gsFg["color.debug"], + gsBg["color.debug"], + input); + } + + return input; +} + +//////////////////////////////////////////////////////////////////////////////// src/rules.cpp @@ -5,4 +5,15 @@ date.t duration.t text.t autocomplete.t -parse.t +seq.t +att.t +record.t +stringtable.t +nibbler.t +subst.t +filt.t +cmd.t +config.t +util.t +color.t +*.log src/tests/.gitignore @@ -1,8 +1,14 @@ -PROJECT = t.t tdb.t date.t duration.t t.benchmark.t text.t autocomplete.t \ - parse.t +PROJECT = t.t tdb.t date.t duration.t t.benchmark.t text.t autocomplete.t \ + config.t seq.t att.t stringtable.t record.t nibbler.t subst.t filt.t \ + cmd.t util.t color.t CFLAGS = -I. -I.. -Wall -pedantic -ggdb3 -fno-rtti -LFLAGS = -L/usr/local/lib -OBJECTS = ../TDB.o ../T.o ../parse.o ../text.o ../Date.o ../util.o ../Config.o +LFLAGS = -L/usr/local/lib -lncurses +OBJECTS = ../TDB.o ../Task.o ../text.o ../Date.o ../Table.o ../Duration.o \ + ../util.o ../Config.o ../Sequence.o ../Att.o ../Cmd.o ../Record.o \ + ../StringTable.o ../Subst.o ../Nibbler.o ../Location.o ../Filter.o \ + ../Context.o ../Keymap.o ../command.o ../interactive.o ../report.o \ + ../Grid.o ../color.o ../rules.o ../recur.o ../custom.o ../import.o \ + ../edit.o ../Timer.o ../Permission.o all: $(PROJECT) @@ -39,6 +45,36 @@ text.t: text.t.o $(OBJECTS) test.o autocomplete.t: autocomplete.t.o $(OBJECTS) test.o g++ autocomplete.t.o $(OBJECTS) test.o $(LFLAGS) -o autocomplete.t -parse.t: parse.t.o $(OBJECTS) test.o - g++ parse.t.o $(OBJECTS) test.o $(LFLAGS) -o parse.t +seq.t: seq.t.o $(OBJECTS) test.o + g++ seq.t.o $(OBJECTS) test.o $(LFLAGS) -o seq.t + +record.t: record.t.o $(OBJECTS) test.o + g++ record.t.o $(OBJECTS) test.o $(LFLAGS) -o record.t + +att.t: att.t.o $(OBJECTS) test.o + g++ att.t.o $(OBJECTS) test.o $(LFLAGS) -o att.t + +stringtable.t: stringtable.t.o $(OBJECTS) test.o + g++ stringtable.t.o $(OBJECTS) test.o $(LFLAGS) -o stringtable.t + +subst.t: subst.t.o $(OBJECTS) test.o + g++ subst.t.o $(OBJECTS) test.o $(LFLAGS) -o subst.t + +nibbler.t: nibbler.t.o $(OBJECTS) test.o + g++ nibbler.t.o $(OBJECTS) test.o $(LFLAGS) -o nibbler.t + +filt.t: filt.t.o $(OBJECTS) test.o + g++ filt.t.o $(OBJECTS) test.o $(LFLAGS) -o filt.t + +cmd.t: cmd.t.o $(OBJECTS) test.o + g++ cmd.t.o $(OBJECTS) test.o $(LFLAGS) -o cmd.t + +config.t: config.t.o $(OBJECTS) test.o + g++ config.t.o $(OBJECTS) test.o $(LFLAGS) -o config.t + +util.t: util.t.o $(OBJECTS) test.o + g++ util.t.o $(OBJECTS) test.o $(LFLAGS) -o util.t + +color.t: color.t.o $(OBJECTS) test.o + g++ color.t.o $(OBJECTS) test.o $(LFLAGS) -o color.t src/tests/Makefile @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 22; +use Test::More tests => 23; # Create the rc file. if (open my $fh, '>', 'abbrev.rc') @@ -92,6 +92,9 @@ like ($output, qr/ABSOLUTELY NO WARRANTY/, 'v'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'abbrev.rc'; ok (!-r 'abbrev.rc', 'Removed abbrev.rc'); src/tests/abbreviation.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 14; +use Test::More tests => 13; # Create the rc file. if (open my $fh, '>', 'add.rc') @@ -39,32 +39,34 @@ if (open my $fh, '>', 'add.rc') } # Test the add command. -my $output = qx{../task rc:add.rc add This is a test; ../task rc:add.rc info 1}; +qx{../task rc:add.rc add This is a test}; +my $output = qx{../task rc:add.rc info 1}; like ($output, qr/ID\s+1\n/, 'add ID'); like ($output, qr/Description\s+This is a test\n/, 'add ID'); like ($output, qr/Status\s+Pending\n/, 'add Pending'); like ($output, qr/UUID\s+[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\n/, 'add UUID'); # Test the /// modifier. -$output = qx{../task rc:add.rc 1 /test/TEST/; ../task rc:add.rc 1 "/is //"; ../task rc:add.rc info 1}; +qx{../task rc:add.rc 1 /test/TEST/}; +qx{../task rc:add.rc 1 "/is //"}; +$output = qx{../task rc:add.rc info 1}; like ($output, qr/ID\s+1\n/, 'add ID'); like ($output, qr/Status\s+Pending\n/, 'add Pending'); like ($output, qr/Description\s+This a TEST\n/, 'add ID'); # Test delete. -$output = qx{../task rc:add.rc delete 1; ../task rc:add.rc info 1}; +qx{../task rc:add.rc delete 1}; +$output = qx{../task rc:add.rc info 1}; like ($output, qr/ID\s+1\n/, 'add ID'); like ($output, qr/Status\s+Deleted\n/, 'add Deleted'); -# Test undelete. -$output = qx{../task rc:add.rc undelete 1; ../task rc:add.rc info 1}; -like ($output, qr/ID\s+1\n/, 'add ID'); -like ($output, qr/Status\s+Pending\n/, 'add Pending'); - # Cleanup. unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'add.rc'; ok (!-r 'add.rc', 'Removed add.rc'); src/tests/add.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'annotate.rc') @@ -67,6 +67,9 @@ like ($output, qr/2 tasks/, 'count'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'annotate.rc'; ok (!-r 'annotate.rc', 'Removed annotate.rc'); src/tests/annotate.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 4; +use Test::More tests => 5; # Create the rc file. if (open my $fh, '>', 'append.rc') @@ -48,6 +48,9 @@ like ($output, qr/Description\s+foo\sbar\n/, 'append worked'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'append.rc'; ok (!-r 'append.rc', 'Removed append.rc'); src/tests/append.t @@ -26,7 +26,10 @@ //////////////////////////////////////////////////////////////////////////////// #include <iostream> #include <test.h> -#include <../task.h> +#include <util.h> +#include <main.h> + +Context context; //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) src/tests/autocomplete.t.cpp @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 7; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'basic.rc') @@ -40,14 +40,13 @@ if (open my $fh, '>', 'basic.rc') # Test the usage command. my $output = qx{../task rc:basic.rc}; -like ($output, qr/Usage: task/, 'usage'); -like ($output, qr/http:\/\/www\.beckingham\.net\/task\.html/, 'usage - url'); +like ($output, qr/You must specify a command, or a task ID to modify/, 'missing command and ID'); # Test the version command. $output = qx{../task rc:basic.rc version}; like ($output, qr/task \d+\.\d+\.\d+/, 'version - task version number'); like ($output, qr/ABSOLUTELY NO WARRANTY/, 'version - warranty'); -like ($output, qr/http:\/\/www\.beckingham\.net\/task\.html/, 'version - url'); +like ($output, qr/http:\/\/taskwarrior\.org/, 'version - url'); # Cleanup. unlink 'basic.rc'; src/tests/basic.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 4; +use Test::More tests => 5; # Create the rc file. if (open my $fh, '>', 'bench.rc') @@ -96,6 +96,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'bench.rc'; ok (!-r 'bench.rc', 'Removed bench.rc'); src/tests/benchmark.t @@ -38,3 +38,16 @@ ok 3 - Removed completed.data ok 4 - Removed bench.rc +6/18/2009 + 1.8.0: + 1..4 + ok 1 - Created bench.rc + # start=1245372501 + # 1000 tasks added in 4 seconds + # 600 tasks altered in 45 seconds + # stop=1245372747 + # total=246 + ok 2 - Removed pending.data + ok 3 - Removed completed.data + ok 4 - Removed bench.rc + src/tests/benchmark.txt @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 13; +use Test::More tests => 14; # Create the rc file. if (open my $fh, '>', 'annual.rc') @@ -57,21 +57,24 @@ if (open my $fh, '>', 'annual.rc') qx{../task rc:annual.rc add foo due:1/1/2000 recur:annual until:1/1/2009}; my $output = qx{../task rc:annual.rc list}; -like ($output, qr/2\s+1\/1\/2000\s+- foo/, 'synthetic 1 no creep'); -like ($output, qr/3\s+1\/1\/2001\s+- foo/, 'synthetic 2 no creep'); -like ($output, qr/4\s+1\/1\/2002\s+- foo/, 'synthetic 3 no creep'); -like ($output, qr/5\s+1\/1\/2003\s+- foo/, 'synthetic 4 no creep'); -like ($output, qr/6\s+1\/1\/2004\s+- foo/, 'synthetic 5 no creep'); -like ($output, qr/7\s+1\/1\/2005\s+- foo/, 'synthetic 6 no creep'); -like ($output, qr/8\s+1\/1\/2006\s+- foo/, 'synthetic 7 no creep'); -like ($output, qr/9\s+1\/1\/2007\s+- foo/, 'synthetic 8 no creep'); -like ($output, qr/10\s+1\/1\/2008\s+- foo/, 'synthetic 9 no creep'); -like ($output, qr/11\s+1\/1\/2009\s+- foo/, 'synthetic 10 no creep'); +like ($output, qr/2\s+1\/1\/2000\s+-\s+foo/, 'synthetic 1 no creep'); +like ($output, qr/3\s+1\/1\/2001\s+-\s+foo/, 'synthetic 2 no creep'); +like ($output, qr/4\s+1\/1\/2002\s+-\s+foo/, 'synthetic 3 no creep'); +like ($output, qr/5\s+1\/1\/2003\s+-\s+foo/, 'synthetic 4 no creep'); +like ($output, qr/6\s+1\/1\/2004\s+-\s+foo/, 'synthetic 5 no creep'); +like ($output, qr/7\s+1\/1\/2005\s+-\s+foo/, 'synthetic 6 no creep'); +like ($output, qr/8\s+1\/1\/2006\s+-\s+foo/, 'synthetic 7 no creep'); +like ($output, qr/9\s+1\/1\/2007\s+-\s+foo/, 'synthetic 8 no creep'); +like ($output, qr/10\s+1\/1\/2008\s+-\s+foo/, 'synthetic 9 no creep'); +like ($output, qr/11\s+1\/1\/2009\s+-\s+foo/, 'synthetic 10 no creep'); # Cleanup. unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'annual.rc'; ok (!-r 'annual.rc', 'Removed annual.rc'); src/tests/bug.annual.t @@ -28,12 +28,13 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'bug_concat.rc') { - print $fh "data.location=.\n"; + print $fh "data.location=.\n", + "confirmation=no\n"; close $fh; ok (-r 'bug_concat.rc', 'Created bug_concat.rc'); } @@ -70,6 +71,9 @@ like ($output, qr/Description\s+aaa bbb:ccc ddd\n/, 'properly concatenated'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'bug_concat.rc'; ok (!-r 'bug_concat.rc', 'Removed bug_concat.rc'); src/tests/bug.concat.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'hang.rc') @@ -76,6 +76,9 @@ ok (!-r 'shadow.txt', 'Removed shadow.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'hang.rc'; ok (!-r 'hang.rc', 'Removed hang.rc'); src/tests/bug.hang.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 41; +use Test::More tests => 42; # Create the rc file. if (open my $fh, '>', 'period.rc') @@ -75,61 +75,61 @@ Confirmed: =cut my $output = qx{../task rc:period.rc add daily due:tomorrow recur:daily}; -like ($output, qr/^$/, 'recur:daily'); +unlike ($output, qr/was not recignized/, 'recur:daily'); $output = qx{../task rc:period.rc add day due:tomorrow recur:day}; -like ($output, qr/^$/, 'recur:day'); +unlike ($output, qr/was not recignized/, 'recur:day'); $output = qx{../task rc:period.rc add weekly due:tomorrow recur:weekly}; -like ($output, qr/^$/, 'recur:weekly'); +unlike ($output, qr/was not recignized/, 'recur:weekly'); $output = qx{../task rc:period.rc add sennight due:tomorrow recur:sennight}; -like ($output, qr/^$/, 'recur:sennight'); +unlike ($output, qr/was not recignized/, 'recur:sennight'); $output = qx{../task rc:period.rc add biweekly due:tomorrow recur:biweekly}; -like ($output, qr/^$/, 'recur:biweekly'); +unlike ($output, qr/was not recignized/, 'recur:biweekly'); $output = qx{../task rc:period.rc add fortnight due:tomorrow recur:fortnight}; -like ($output, qr/^$/, 'recur:fortnight'); +unlike ($output, qr/was not recignized/, 'recur:fortnight'); $output = qx{../task rc:period.rc add monthly due:tomorrow recur:monthly}; -like ($output, qr/^$/, 'recur:monthly'); +unlike ($output, qr/was not recignized/, 'recur:monthly'); $output = qx{../task rc:period.rc add quarterly due:tomorrow recur:quarterly}; -like ($output, qr/^$/, 'recur:quarterly'); +unlike ($output, qr/was not recignized/, 'recur:quarterly'); $output = qx{../task rc:period.rc add semiannual due:tomorrow recur:semiannual}; -like ($output, qr/^$/, 'recur:semiannual'); +unlike ($output, qr/was not recignized/, 'recur:semiannual'); $output = qx{../task rc:period.rc add bimonthly due:tomorrow recur:bimonthly}; -like ($output, qr/^$/, 'recur:bimonthly'); +unlike ($output, qr/was not recignized/, 'recur:bimonthly'); $output = qx{../task rc:period.rc add biannual due:tomorrow recur:biannual}; -like ($output, qr/^$/, 'recur:biannual'); +unlike ($output, qr/was not recignized/, 'recur:biannual'); $output = qx{../task rc:period.rc add biyearly due:tomorrow recur:biyearly}; -like ($output, qr/^$/, 'recur:biyearly'); +unlike ($output, qr/was not recignized/, 'recur:biyearly'); $output = qx{../task rc:period.rc add annual due:tomorrow recur:annual}; -like ($output, qr/^$/, 'recur:annual'); +unlike ($output, qr/was not recignized/, 'recur:annual'); $output = qx{../task rc:period.rc add yearly due:tomorrow recur:yearly}; -like ($output, qr/^$/, 'recur:yearly'); +unlike ($output, qr/was not recignized/, 'recur:yearly'); $output = qx{../task rc:period.rc add 2d due:tomorrow recur:2d}; -like ($output, qr/^$/, 'recur:2m'); +unlike ($output, qr/was not recignized/, 'recur:2m'); $output = qx{../task rc:period.rc add 2w due:tomorrow recur:2w}; -like ($output, qr/^$/, 'recur:2q'); +unlike ($output, qr/was not recignized/, 'recur:2q'); $output = qx{../task rc:period.rc add 2m due:tomorrow recur:2m}; -like ($output, qr/^$/, 'recur:2d'); +unlike ($output, qr/was not recignized/, 'recur:2d'); $output = qx{../task rc:period.rc add 2q due:tomorrow recur:2q}; -like ($output, qr/^$/, 'recur:2w'); +unlike ($output, qr/was not recignized/, 'recur:2w'); $output = qx{../task rc:period.rc add 2y due:tomorrow recur:2y}; -like ($output, qr/^$/, 'recur:2y'); +unlike ($output, qr/was not recignized/, 'recur:2y'); # Verify that the recurring task instances get created. One of each. $output = qx{../task rc:period.rc list}; @@ -157,6 +157,9 @@ like ($output, qr/\b2y\b/, 'verify 2y'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'period.rc'; ok (!-r 'period.rc', 'Removed period.rc'); src/tests/bug.period.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'bug_sort.rc') @@ -54,6 +54,9 @@ like ($output, qr/three.*one.*two/msi, 'list did not hang after pri:H on 1'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'bug_sort.rc'; ok (!-r 'bug_sort.rc', 'Removed bug_sort.rc'); src/tests/bug.sort.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'summary.rc') @@ -60,6 +60,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'summary.rc'; ok (!-r 'summary.rc', 'Removed summary.rc'); src/tests/bug.summary.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -53,6 +53,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m /x, 'color.active'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.active.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -51,6 +51,9 @@ unlike ($output, qr/\033\[0m/, 'color.disable - no color reset'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.disable.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -52,6 +52,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m/x, 'color.due'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.due.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -55,6 +55,9 @@ like ($output, qr/ \033\[32m .* green .* \033\[0m /x, 'color.keywo unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.keyword.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -52,6 +52,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m/x, 'color.overdue'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.overdue.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 7; +use Test::More tests => 8; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -59,6 +59,9 @@ like ($output, qr/ \033\[33m .* yellow .* \033\[0m /x, 'color.pri.none'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.pri.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -52,6 +52,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m /x, 'color.project.re unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.project.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -52,6 +52,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m /x, 'color.recur unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.recurring.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -55,6 +55,9 @@ like ($output, qr/ \033\[32m .* green .* \033\[0m /x, 'color.tag.green' unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.tag.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'color.rc') @@ -52,6 +52,9 @@ like ($output, qr/ \033\[31m .* red .* \033\[0m /x, 'color.tagged'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'color.rc'; ok (!-r 'color.rc', 'Removed color.rc'); src/tests/color.tagged.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'completed.rc') @@ -57,6 +57,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'completed.rc'; ok (!-r 'completed.rc', 'Removed completed.rc'); src/tests/completed.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'obsolete.rc') @@ -50,6 +50,9 @@ like ($output, qr/ foo\n/, 'unsupported configuration variable'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'obsolete.rc'; ok (!-r 'obsolete.rc', 'Removed obsolete.rc'); src/tests/config.obsolete.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 26; +use Test::More tests => 27; # Create the rc file. if (open my $fh, '>', 'confirm.rc') @@ -99,6 +99,9 @@ like ($output, qr/(Permanently delete task 7 'foo'\? \(y\/n\)) \1 \1/, 'confirma unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'response.txt'; ok (!-r 'response.txt', 'Removed response.txt'); src/tests/confirmation.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 4; +use Test::More tests => 5; # Create the rc file. if (open my $fh, '>', 'custom.rc') @@ -50,6 +50,9 @@ like ($output, qr/Unrecognized column name: foo\n/, 'custom report spotted inval unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'custom.rc'; ok (!-r 'custom.rc', 'Removed custom.rc'); src/tests/custom.columns.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'custom.rc') @@ -54,6 +54,9 @@ unlike ($output, qr/2\s+R/, 'No recurrence indicator t2'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'custom.rc'; ok (!-r 'custom.rc', 'Removed custom.rc'); src/tests/custom.recur_ind.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'custom.rc') @@ -56,6 +56,9 @@ unlike ($output, qr/two/, 'custom filter excluded'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'custom.rc'; ok (!-r 'custom.rc', 'Removed custom.rc'); src/tests/custom.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'custom.rc') @@ -54,6 +54,9 @@ unlike ($output, qr/2\s+\+/, 'No tag indicator t2'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'custom.rc'; ok (!-r 'custom.rc', 'Removed custom.rc'); src/tests/custom.tag_ind.t @@ -25,13 +25,16 @@ // //////////////////////////////////////////////////////////////////////////////// #include <iostream> +#include <Context.h> #include <Date.h> #include <test.h> +Context context; + //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { - UnitTest t (100); + UnitTest t (102); try { @@ -72,11 +75,14 @@ int main (int argc, char** argv) t.ok (Date::valid (2, 29, 2008), "valid: 2/29/2008"); t.notok (Date::valid (2, 29, 2007), "invalid: 2/29/2007"); + t.ok (Date::valid ("2/29/2008"), "valid: 2/29/2008"); + t.notok (Date::valid ("2/29/2007"), "invalid: 2/29/2007"); + // Leap year. t.ok (Date::leapYear (2008), "2008 is a leap year"); t.notok (Date::leapYear (2007), "2007 is not a leap year"); t.ok (Date::leapYear (2000), "2000 is a leap year"); - t.ok (Date::leapYear (1900), "1900 is a leap year"); + t.notok (Date::leapYear (1900), "1900 is not a leap year"); // Days in month. t.is (Date::daysInMonth (2, 2008), 29, "29 days in February 2008"); @@ -132,8 +138,8 @@ int main (int argc, char** argv) Date epoch (9, 8, 2001); t.ok ((int)epoch.toEpoch () < 1000000000, "9/8/2001 < 1,000,000,000"); - epoch += 86400; - t.ok ((int)epoch.toEpoch () > 1000000000, "9/9/2001 > 1,000,000,000"); + epoch += 172800; + t.ok ((int)epoch.toEpoch () > 1000000000, "9/10/2001 > 1,000,000,000"); Date fromEpoch (epoch.toEpoch ()); t.is (fromEpoch.toString (), epoch.toString (), "ctor (time_t)"); src/tests/date.t.cpp @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'date1.rc') @@ -62,6 +62,9 @@ like ($output, qr/\b12\/1\/09\b/, 'date format m/d/y parsed'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'date1.rc'; ok (!-r 'date1.rc', 'Removed date1.rc'); src/tests/dateformat.t @@ -28,13 +28,13 @@ use strict; use warnings; -use Test::More tests => 16; +use Test::More tests => 17; # Create the rc file. if (open my $fh, '>', 'default.rc') { print $fh "data.location=.\n", - "default.command=list\n", + "default.command=rc:default.rc list\n", "default.project=PROJECT\n", "default.priority=M\n"; close $fh; @@ -76,6 +76,9 @@ like ($output, qr/1 PROJECT L .+ priority specified/, 'default command worked'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'default.rc'; ok (!-r 'default.rc', 'Removed default.rc'); src/tests/default.t @@ -28,39 +28,36 @@ use strict; use warnings; -use Test::More tests => 16; +use Test::More tests => 17; # Create the rc file. -if (open my $fh, '>', 'undelete.rc') +if (open my $fh, '>', 'delete.rc') { print $fh "data.location=.\n", "echo.command=no\n"; close $fh; - ok (-r 'undelete.rc', 'Created undelete.rc'); + ok (-r 'delete.rc', 'Created delete.rc'); } # Add a task, delete it, undelete it. -my $output = qx{../task rc:undelete.rc add one; ../task rc:undelete.rc info 1}; +my $output = qx{../task rc:delete.rc add one; ../task rc:delete.rc info 1}; ok (-r 'pending.data', 'pending.data created'); like ($output, qr/Status\s+Pending\n/, 'Pending'); -$output = qx{../task rc:undelete.rc delete 1; ../task rc:undelete.rc info 1}; +$output = qx{../task rc:delete.rc delete 1; ../task rc:delete.rc info 1}; like ($output, qr/Status\s+Deleted\n/, 'Deleted'); -ok (! -r 'completed.data', 'completed.data not created'); +ok (-r 'completed.data', 'completed.data created'); -$output = qx{../task rc:undelete.rc undelete 1; ../task rc:undelete.rc info 1}; +$output = qx{echo 'y' | ../task rc:delete.rc undo; ../task rc:delete.rc info 1}; like ($output, qr/Status\s+Pending\n/, 'Pending'); -ok (! -r 'completed.data', 'completed.data not created'); - -$output = qx{../task rc:undelete.rc delete 1; ../task rc:undelete.rc list}; -like ($output, qr/^No matches/, 'No matches'); ok (-r 'completed.data', 'completed.data created'); -$output = qx{../task rc:undelete.rc undelete 1}; -like ($output, qr/Task 1 not found/, 'Task 1 not found'); +$output = qx{../task rc:delete.rc delete 1; ../task rc:delete.rc list}; +like ($output, qr/No matches./, 'No matches'); +ok (-r 'completed.data', 'completed.data created'); -$output = qx{../task rc:undelete.rc info 1}; -like ($output, qr/No matches./, 'no matches'); +$output = qx{../task rc:delete.rc info 1}; +like ($output, qr/Task 1 not found/, 'No matches'); # Cleanup. ok (-r 'pending.data', 'Need to remove pending.data'); @@ -71,8 +68,12 @@ ok (-r 'completed.data', 'Need to remove completed.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); -unlink 'undelete.rc'; -ok (!-r 'undelete.rc', 'Removed undelete.rc'); +ok (-r 'undo.data', 'Need to remove undo.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + +unlink 'delete.rc'; +ok (!-r 'delete.rc', 'Removed delete.rc'); exit 0; src/tests/delete.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'due.rc') @@ -60,6 +60,9 @@ like ($output, qr/\s+$almost\s+/, 'two not marked due'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'due.rc'; ok (!-r 'due.rc', 'Removed due.rc'); src/tests/due.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 11; +use Test::More tests => 12; # Create the rc file. if (open my $fh, '>', 'dup.rc') @@ -59,6 +59,9 @@ like ($output, qr/Tags\s+tag/, 'duplicate added tag'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'dup.rc'; ok (!-r 'dup.rc', 'Removed dup.rc'); src/tests/duplicate.t @@ -25,40 +25,71 @@ // //////////////////////////////////////////////////////////////////////////////// #include <iostream> -#include <Date.h> +#include <Context.h> +#include <Duration.h> #include <test.h> -#include <../task.h> + +Context context; //////////////////////////////////////////////////////////////////////////////// // daily, day, Nd -// weekly, Nw, sennight, biweekly, fortnight +// weekly, 1w, sennight, biweekly, fortnight // monthly, bimonthly, Nm, semimonthly // 1st 2nd 3rd 4th .. 31st -// quarterly, Nq -// biannual, biyearly, annual, semiannual, yearly, Ny +// quarterly, 1q +// biannual, biyearly, annual, semiannual, yearly, 1y + +int convertDuration (const std::string& input) +{ + try { Duration d (input); return (int) d; } + catch (...) {} + return 0; +} + int main (int argc, char** argv) { - UnitTest t (17); + UnitTest t (35); + + Duration d; + t.ok (d.valid ("daily"), "duration daily = 1"); + t.ok (d.valid ("weekdays"), "duration weekdays = 1"); + t.ok (d.valid ("day"), "duration day = 1"); + t.ok (d.valid ("0d"), "duration 0d = 0"); + t.ok (d.valid ("1d"), "duration 1d = 1"); + t.ok (d.valid ("7d"), "duration 7d = 7"); + t.ok (d.valid ("10d"), "duration 10d = 10"); + t.ok (d.valid ("100d"), "duration 100d = 100"); + + t.ok (d.valid ("weekly"), "duration weekly = 7"); + t.ok (d.valid ("sennight"), "duration sennight = 7"); + t.ok (d.valid ("biweekly"), "duration biweekly = 14"); + t.ok (d.valid ("fortnight"), "duration fortnight = 14"); + t.ok (d.valid ("0w"), "duration 0w = 0"); + t.ok (d.valid ("1w"), "duration 1w = 7"); + t.ok (d.valid ("7w"), "duration 7w = 49"); + t.ok (d.valid ("10w"), "duration 10w = 70"); + t.ok (d.valid ("100w"), "duration 100w = 700"); + + t.notok (d.valid ("woof"), "duration woof = fail"); - std::string d; - d = "daily"; t.is (convertDuration (d), 1, "duration daily = 1"); - d = "weekdays"; t.is (convertDuration (d), 1, "duration weekdays = 1"); - d = "day"; t.is (convertDuration (d), 1, "duration day = 1"); - d = "0d"; t.is (convertDuration (d), 0, "duration 0d = 0"); - d = "1d"; t.is (convertDuration (d), 1, "duration 1d = 1"); - d = "7d"; t.is (convertDuration (d), 7, "duration 7d = 7"); - d = "10d"; t.is (convertDuration (d), 10, "duration 10d = 10"); - d = "100d"; t.is (convertDuration (d), 100, "duration 100d = 100"); + t.is (convertDuration ("daily"), 1, "duration daily = 1"); + t.is (convertDuration ("weekdays"), 1, "duration weekdays = 1"); + t.is (convertDuration ("day"), 1, "duration day = 1"); + t.is (convertDuration ("0d"), 0, "duration 0d = 0"); + t.is (convertDuration ("1d"), 1, "duration 1d = 1"); + t.is (convertDuration ("7d"), 7, "duration 7d = 7"); + t.is (convertDuration ("10d"), 10, "duration 10d = 10"); + t.is (convertDuration ("100d"), 100, "duration 100d = 100"); - d = "weekly"; t.is (convertDuration (d), 7, "duration weekly = 7"); - d = "sennight"; t.is (convertDuration (d), 7, "duration sennight = 7"); - d = "biweekly"; t.is (convertDuration (d), 14, "duration biweekly = 14"); - d = "fortnight"; t.is (convertDuration (d), 14, "duration fortnight = 14"); - d = "0w"; t.is (convertDuration (d), 0, "duration 0w = 0"); - d = "1w"; t.is (convertDuration (d), 7, "duration 1w = 7"); - d = "7w"; t.is (convertDuration (d), 49, "duration 7w = 49"); - d = "10w"; t.is (convertDuration (d), 70, "duration 10w = 70"); - d = "100w"; t.is (convertDuration (d), 700, "duration 100w = 700"); + t.is (convertDuration ("weekly"), 7, "duration weekly = 7"); + t.is (convertDuration ("sennight"), 7, "duration sennight = 7"); + t.is (convertDuration ("biweekly"), 14, "duration biweekly = 14"); + t.is (convertDuration ("fortnight"), 14, "duration fortnight = 14"); + t.is (convertDuration ("0w"), 0, "duration 0w = 0"); + t.is (convertDuration ("1w"), 7, "duration 1w = 7"); + t.is (convertDuration ("7w"), 49, "duration 7w = 49"); + t.is (convertDuration ("10w"), 70, "duration 10w = 70"); + t.is (convertDuration ("100w"), 700, "duration 100w = 700"); return 0; } src/tests/duration.t.cpp @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 11; +use Test::More tests => 12; # Create the rc file. if (open my $fh, '>', 'enp.rc') @@ -57,6 +57,9 @@ like ($output, qr/Tags\s+tag/, 'en passant 2 description change'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'enp.rc'; ok (!-r 'enp.rc', 'Removed enp.rc'); src/tests/enpassant.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 7; +use Test::More tests => 8; # Create the rc file. if (open my $fh, '>', 'export.rc') @@ -41,16 +41,21 @@ if (open my $fh, '>', 'export.rc') # Add two tasks, export, examine result. qx{../task rc:export.rc add priority:H project:A one}; qx{../task rc:export.rc add +tag1 +tag2 two}; -qx{../task rc:export.rc export ./export.txt}; +qx{../task rc:export.rc export > ./export.txt}; my @lines; if (open my $fh, '<', './export.txt') { - @lines = <$fh>; + while (my $line = <$fh>) + { + next unless $line =~ /^['0-9]/; + push @lines, $line; + } + close $fh; } -my $line1 = qr/'id','uuid','status','tags','entry','start','due','recur','end','project','priority','fg','bg','description'\n/; +my $line1 = qr/'uuid','status','tags','entry','start','due','recur','end','project','priority','fg','bg','description'\n/; my $line2 = qr/'.{8}-.{4}-.{4}-.{4}-.{12}','pending','',\d+,,,,,'A','H',,,'one'\n/; my $line3 = qr/'.{8}-.{4}-.{4}-.{4}-.{12}','pending','tag1 tag2',\d+,,,,,,,,,'two'\n/; @@ -65,6 +70,9 @@ ok (!-r 'export.txt', 'Removed export.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'export.rc'; ok (!-r 'export.rc', 'Removed export.rc'); src/tests/export.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 108; +use Test::More tests => 130; # Create the rc file. if (open my $fh, '>', 'filter.rc') @@ -110,6 +110,33 @@ like ($output, qr/five/, 'g5'); unlike ($output, qr/six/, 'g6'); unlike ($output, qr/seven/, 'g7'); +$output = qx{../task rc:filter.rc list -tag}; +unlike ($output, qr/one/, 'g1'); +like ($output, qr/two/, 'g2'); +like ($output, qr/three/, 'g3'); +like ($output, qr/four/, 'g4'); +unlike ($output, qr/five/, 'g5'); +like ($output, qr/six/, 'g6'); +like ($output, qr/seven/, 'g7'); + +$output = qx{../task rc:filter.rc list -missing}; +like ($output, qr/one/, 'g1'); +like ($output, qr/two/, 'g2'); +like ($output, qr/three/, 'g3'); +like ($output, qr/four/, 'g4'); +like ($output, qr/five/, 'g5'); +like ($output, qr/six/, 'g6'); +like ($output, qr/seven/, 'g7'); + +$output = qx{../task rc:filter.rc list +tag -tag}; +unlike ($output, qr/one/, 'g1'); +unlike ($output, qr/two/, 'g2'); +unlike ($output, qr/three/, 'g3'); +unlike ($output, qr/four/, 'g4'); +unlike ($output, qr/five/, 'g5'); +unlike ($output, qr/six/, 'g6'); +unlike ($output, qr/seven/, 'g7'); + $output = qx{../task rc:filter.rc list project:A priority:H}; like ($output, qr/one/, 'h1'); like ($output, qr/two/, 'h2'); @@ -186,6 +213,9 @@ unlike ($output, qr/seven/, 'n7'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'filter.rc'; ok (!-r 'filter.rc', 'Removed filter.rc'); src/tests/filter.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 2 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 2 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+A.+M.+foo bar/, 't1'); @@ -63,6 +63,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.143.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 2 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 2 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+A.+M.+foo bar/, 't1'); @@ -63,6 +63,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.150.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 2 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 2 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+A.+M.+foo bar/, 't1'); @@ -63,6 +63,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.160.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -49,7 +49,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 2 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 2 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+A.+H.+This is a test/, 't1'); @@ -62,6 +62,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.cmd.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 2 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 2 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+H.+this is a test/, 't1'); @@ -63,6 +63,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.csv.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 10; +use Test::More tests => 11; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 3 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 3 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+project.+This is a test/, 't1'); @@ -69,6 +69,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.todo.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 9; +use Test::More tests => 10; # Create the rc file. if (open my $fh, '>', 'import.rc') @@ -50,7 +50,7 @@ if (open my $fh, '>', 'import.txt') } my $output = qx{../task rc:import.rc import import.txt}; -is ($output, "Imported 3 tasks successfully, with 0 errors.\n", 'no errors'); +like ($output, qr/Imported 3 tasks successfully, with 0 errors./, 'no errors'); $output = qx{../task rc:import.rc list}; like ($output, qr/1.+Get milk, bread/, 't1'); @@ -64,6 +64,9 @@ ok (!-r 'import.txt', 'Removed import.txt'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'import.rc'; ok (!-r 'import.rc', 'Removed import.rc'); src/tests/import.txt.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 8; +use Test::More tests => 9; # Create the rc file. if (open my $fh, '>', 'custom.rc') @@ -59,6 +59,9 @@ unlike ($output, qr/two/, 'custom filter excluded'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'custom.rc'; ok (!-r 'custom.rc', 'Removed custom.rc'); src/tests/label.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 9; +use Test::More tests => 10; # Create the rc file. if (open my $fh, '>', 'nag.rc') @@ -58,6 +58,9 @@ unlike (qx{../task rc:nag.rc do 1}, qr/NAG/, 'do due:yesterday -> no nag'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'nag.rc'; ok (!-r 'nag.rc', 'Removed nag.rc'); src/tests/nag.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'next.rc') @@ -54,6 +54,9 @@ like ($output, qr/\s3\sB\s+H\s+-\sBH\n/, 'BH shown'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'next.rc'; ok (!-r 'next.rc', 'Removed next.rc'); src/tests/next.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 55; +use Test::More tests => 56; # Create the rc file. if (open my $fh, '>', 'oldest.rc') @@ -78,7 +78,7 @@ like ($output, qr/nine/, 'oldest: nine'); like ($output, qr/ten/, 'oldest: ten'); unlike ($output, qr/eleven/, 'no: eleven'); -$output = qx{../task rc:oldest.rc oldest 3}; +$output = qx{../task rc:oldest.rc oldest limit:3}; like ($output, qr/one/, 'oldest: one'); like ($output, qr/two/, 'oldest: two'); like ($output, qr/three/, 'oldest: three'); @@ -104,7 +104,7 @@ like ($output, qr/nine/, 'newest: nine'); like ($output, qr/ten/, 'newest: ten'); like ($output, qr/eleven/, 'newest: eleven'); -$output = qx{../task rc:oldest.rc newest 3}; +$output = qx{../task rc:oldest.rc newest limit:3}; unlike ($output, qr/one/, 'no: one'); unlike ($output, qr/two/, 'no: two'); unlike ($output, qr/three/, 'no: three'); @@ -121,6 +121,9 @@ like ($output, qr/eleven/, 'newest: eleven'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'oldest.rc'; ok (!-r 'oldest.rc', 'Removed oldest.rc'); src/tests/oldest.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'due.rc') @@ -53,6 +53,9 @@ unlike ($output, qr/three/, 'overdue: task 3 does not show up'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'due.rc'; ok (!-r 'due.rc', 'Removed due.rc'); src/tests/overdue.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 5; +use Test::More tests => 6; # Create the rc file. if (open my $fh, '>', 'recur.rc') @@ -57,6 +57,9 @@ like ($output, qr/second .* third .* first/msx, 'weekly 3d daily'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'recur.rc'; ok (!-r 'recur.rc', 'Removed recur.rc'); src/tests/recur.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 7; +use Test::More tests => 8; # Create the rc file. if (open my $fh, '>', 'recur.rc') @@ -57,6 +57,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'recur.rc'; ok (!-r 'recur.rc', 'Removed recur.rc'); src/tests/recur.weekdays.t @@ -9,3 +9,26 @@ done date >> all.log +START=`head -1 all.log` +END=`tail -1 all.log` +OS=`uname` + +case $OS in + Darwin) + STARTEPOCH=`date -j -f "%a %b %d %T %Z %Y" "${START}" "+%s"` + ENDEPOCH=`date -j -f "%a %b %d %T %Z %Y" "${END}" "+%s"` + ;; + Linux) + STARTEPOCH=`date "+%s" -d "${START}"` + ENDEPOCH=`date "+%s" -d "${END}"` + ;; +esac + +RUNTIME=$(($ENDEPOCH - $STARTEPOCH)) + +echo -n 'Pass: ' +grep ^ok all.log | wc -l +echo -n 'Fail: ' +grep ^not all.log | wc -l +echo -n 'Runtime: ' +echo $RUNTIME src/tests/run_all @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 27; +use Test::More tests => 28; # Create the rc file. if (open my $fh, '>', 'seq.rc') @@ -46,7 +46,8 @@ my $output = qx{../task rc:seq.rc info 1}; like ($output, qr/Status\s+Completed/, 'sequence do 1'); $output = qx{../task rc:seq.rc info 2}; like ($output, qr/Status\s+Completed/, 'sequence do 2'); -qx{../task rc:seq.rc undo 1,2}; +qx{echo 'y'|../task rc:seq.rc undo}; +qx{echo 'y'|../task rc:seq.rc undo}; $output = qx{../task rc:seq.rc info 1}; like ($output, qr/Status\s+Pending/, 'sequence undo 1'); $output = qx{../task rc:seq.rc info 2}; @@ -58,11 +59,12 @@ $output = qx{../task rc:seq.rc info 1}; like ($output, qr/Status\s+Deleted/, 'sequence delete 1'); $output = qx{../task rc:seq.rc info 2}; like ($output, qr/Status\s+Deleted/, 'sequence delete 2'); -qx{../task rc:seq.rc undelete 1,2}; +qx{echo 'y'|../task rc:seq.rc undo}; +qx{echo 'y'|../task rc:seq.rc undo}; $output = qx{../task rc:seq.rc info 1}; -like ($output, qr/Status\s+Pending/, 'sequence undelete 1'); +like ($output, qr/Status\s+Pending/, 'sequence undo 1'); $output = qx{../task rc:seq.rc info 2}; -like ($output, qr/Status\s+Pending/, 'sequence undelete 2'); +like ($output, qr/Status\s+Pending/, 'sequence undo 2'); # Test sequences in start/stop qx{../task rc:seq.rc start 1,2}; @@ -118,6 +120,9 @@ like ($output, qr/\d+\/\d+\/\d+ note/, 'sequence annotate 2'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'seq.rc'; ok (!-r 'seq.rc', 'Removed seq.rc'); src/tests/sequence.t @@ -28,14 +28,14 @@ use strict; use warnings; -use Test::More tests => 21; +use Test::More tests => 22; # Create the rc file. if (open my $fh, '>', 'shadow.rc') { print $fh "data.location=.\n", "shadow.file=./shadow.txt\n", - "shadow.command=stats\n", + "shadow.command=rc:shadow.rc stats\n", "shadow.notify=on\n"; close $fh; ok (-r 'shadow.rc', 'Created shadow.rc'); @@ -51,7 +51,7 @@ $output = qx{../task rc:shadow.rc delete 1}; like ($output, qr/\[Shadow file '\.\/shadow\.txt' updated\]/, 'shadow file updated on delete'); $output = qx{../task rc:shadow.rc list}; -like ($output, qr/\[Shadow file '\.\/shadow\.txt' updated\]/, 'shadow file updated on list'); +unlike ($output, qr/\[Shadow file '\.\/shadow\.txt' updated\]/, 'shadow file not updated on list'); # Inspect the shadow file. my $file = slurp ('./shadow.txt'); @@ -75,6 +75,9 @@ ok (!-r 'pending.data', 'Removed pending.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'shadow.rc'; ok (!-r 'shadow.rc', 'Removed shadow.rc'); src/tests/shadow.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 12; +use Test::More tests => 14; # Create the rc file. if (open my $fh, '>', 'start.rc') @@ -66,6 +66,10 @@ ok (-r 'pending.data', 'Need to remove pending.data'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +ok (-r 'undo.data', 'Need to remove undo.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'start.rc'; ok (!-r 'start.rc', 'Removed start.rc'); src/tests/start.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 11; +use Test::More tests => 12; # Create the rc file. if (open my $fh, '>', 'sp.rc') @@ -60,12 +60,15 @@ $output = qx{../task rc:sp.rc list project:abc}; like ($output, qr/\babc\s*$/m, 'abc,ab,a,b | a -> abc'); $output = qx{../task rc:sp.rc list project:abcd}; -like ($output, qr/^No matches.$/, 'abc,ab,a,b | abcd -> nul'); +like ($output, qr/No matches./, 'abc,ab,a,b | abcd -> nul'); # Cleanup. unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'sp.rc'; ok (!-r 'sp.rc', 'Removed sp.rc'); src/tests/subproject.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 9; +use Test::More tests => 10; # Create the rc file. if (open my $fh, '>', 'subst.rc') @@ -72,6 +72,9 @@ like ($output, qr/aaa ccc/, 'word deletion in description'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'subst.rc'; ok (!-r 'subst.rc', 'Removed subst.rc'); src/tests/substitute.t @@ -25,20 +25,30 @@ // //////////////////////////////////////////////////////////////////////////////// #include <sys/time.h> -#include "../T.h" -#include "../task.h" +#include "Task.h" +#include "main.h" #include "test.h" +Context context; + //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { UnitTest test (1); - std::string sample = "d346065c-7ef6-49af-ae77-19c1825807f5 " - "- " - "[bug performance solaris linux osx] " - "[due:1236142800 entry:1236177552 priority:H project:task-1.5.0 start:1236231761] " - "Profile task and identify performance bottlenecks"; + // FF4 parsing is being tested. Performance of legacy format parsing is + // immaterial. + std::string sample = "[" + "uuid:\"d346065c-7ef6-49af-ae77-19c1825807f5\" " + "status:\"pending\" " + "tags:\"bug,performance,solaris,linux,osx\" " + "due:\"1236142800\" " + "entry:\"1236177552\" " + "priority:\"H\" " + "project:\"task-1.5.0\" " + "start:\"1236231761\" " + "description:\"Profile task and identify performance bottlenecks\"" + "]"; // Start clock test.diag ("start"); @@ -47,7 +57,7 @@ int main (int argc, char** argv) for (int i = 0; i < 1000000; i++) { - T t (sample); + Task t (sample); } // End clock src/tests/t.benchmark.t.cpp @@ -24,70 +24,141 @@ // USA // //////////////////////////////////////////////////////////////////////////////// -#include "../T.h" -#include "../task.h" +#include "main.h" #include "test.h" +Context context; + //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { - UnitTest test (10); - - T t; - std::string s = t.compose (); - test.is ((int)s.length (), 49, "T::T (); T::compose ()"); - test.diag (s); - - t.setStatus (T::completed); - s = t.compose (); - test.is (s[37], '+', "T::setStatus (completed)"); - test.diag (s); - - t.setStatus (T::deleted); - s = t.compose (); - test.is (s[37], 'X', "T::setStatus (deleted)"); - test.diag (s); - - t.setStatus (T::recurring); - s = t.compose (); - test.is (s[37], 'r', "T::setStatus (recurring)"); - test.diag (s); - - std::string format3 = "00000000-0000-0000-0000-000000000000 - [] [] [] Sample\n"; - - // Format 1 Round trip test. - std::string sample = "[] [] Sample"; - T tf1; - tf1.parse (sample); - test.is (tf1.compose ().substr (36, std::string::npos), - format3.substr (36, std::string::npos), - "T::parse format 1 -> T::compose round trip"); - - // Format 2 Round trip test. - sample = "00000000-0000-0000-0000-000000000000 - [] [] Sample"; - T tf2; - tf2.parse (sample); - test.is (tf2.compose (), format3, "T::parse format 2 -> T::compose round trip"); - - // Format 3 Round trip test. - sample = "00000000-0000-0000-0000-000000000000 - [] [] [] Sample"; - T tf3; - tf3.parse (sample); - test.is (tf3.compose (), format3, "T::parse format 3 -> T::compose round trip"); - - // b10b3236-70d8-47bb-840a-b4c430758fb6 - [foo] [bar:baz] [1237865996:'woof'] sample\n - // ....:....|....:....|....:....|....:....|....:....|....:....|....:....|....:....|....:....| - // ^ ^ ^ - // 0 36 66 - t.setStatus (T::pending); - t.addTag ("foo"); - t.setAttribute ("bar", "baz"); - t.addAnnotation ("woof"); - t.setDescription ("sample"); - std::string format = t.compose (); - test.is (format.substr (36, 20), " - [foo] [bar:baz] [", "compose tag, attribute"); - test.is (format.substr (66, 16), ":\"woof\"] sample\n", "compose annotation"); - test.is (t.getAnnotationCount (), 1, "annotation count"); + UnitTest test (37); + + test.is ((int)Task::textToStatus ("pending"), (int)Task::pending, "textToStatus pending"); + test.is ((int)Task::textToStatus ("completed"), (int)Task::completed, "textToStatus completed"); + test.is ((int)Task::textToStatus ("deleted"), (int)Task::deleted, "textToStatus deleted"); + test.is ((int)Task::textToStatus ("recurring"), (int)Task::recurring, "textToStatus recurring"); + + test.is (Task::statusToText (Task::pending), "pending", "statusToText pending"); + test.is (Task::statusToText (Task::completed), "completed", "statusToText completed"); + test.is (Task::statusToText (Task::deleted), "deleted", "statusToText deleted"); + test.is (Task::statusToText (Task::recurring), "recurring", "statusToText recurring"); + + // Round-trip testing. + Task t3; + t3.set ("name", "value"); + std::string before = t3.composeF4 (); + t3.parse (before); + std::string after = t3.composeF4 (); + t3.parse (after); + after = t3.composeF4 (); + t3.parse (after); + after = t3.composeF4 (); + test.is (before, after, "Task::composeF4 -> parse round trip 4 iterations"); + + // Legacy Format 1 + // [tags] [attributes] description\n + // X [tags] [attributes] description\n + std::string sample = "[tag1 tag2] [att1:value1 att2:value2] Description"; + sample = "X " + "[one two] " + "[att1:value1 att2:value2] " + "Description"; + bool good = true; + try { Task ff1 (sample); } catch (...) { good = false; } + test.notok (good, "Support for ff1 removed"); + + // Legacy Format 2 + // uuid status [tags] [attributes] description\n + sample = "00000000-0000-0000-0000-000000000000 " + "- " + "[tag1 tag2] " + "[att1:value1 att2:value2] " + "Description"; + Task ff2 (sample); + std::string value = ff2.get ("uuid"); + test.is (value, "00000000-0000-0000-0000-000000000000", "ff2 uuid"); + value = ff2.get ("status"); + test.is (value, "pending", "ff2 status"); + test.ok (ff2.hasTag ("tag1"), "ff2 tag1"); + test.ok (ff2.hasTag ("tag2"), "ff2 tag2"); + test.is (ff2.getTagCount (), 2, "ff2 # tags"); + value = ff2.get ("att1"); + test.is (value, "value1", "ff2 att1"); + value = ff2.get ("att2"); + test.is (value, "value2", "ff2 att2"); + value = ff2.get ("description"); + test.is (value, "Description", "ff2 description"); + + // Legacy Format 3 + // uuid status [tags] [attributes] [annotations] description\n + sample = "00000000-0000-0000-0000-000000000000 " + "- " + "[tag1 tag2] " + "[att1:value1 att2:value2] " + "[123:ann1 456:ann2] Description"; + Task ff3 (sample); + value = ff2.get ("uuid"); + test.is (value, "00000000-0000-0000-0000-000000000000", "ff3 uuid"); + value = ff2.get ("status"); + test.is (value, "pending", "ff3 status"); + test.ok (ff2.hasTag ("tag1"), "ff3 tag1"); + test.ok (ff2.hasTag ("tag2"), "ff3 tag2"); + test.is (ff2.getTagCount (), 2, "ff3 # tags"); + value = ff3.get ("att1"); + test.is (value, "value1", "ff3 att1"); + value = ff3.get ("att2"); + test.is (value, "value2", "ff3 att2"); + value = ff3.get ("description"); + test.is (value, "Description", "ff3 description"); + + // Current Format 4 + // [name:"value" ...]\n + sample = "[" + "uuid:\"00000000-0000-0000-0000-000000000000\" " + "status:\"P\" " + "tags:\"tag1&commaltag2\" " + "att1:\"value1\" " + "att2:\"value2\" " + "description:\"Description\"" + "]"; + Task ff4 (sample); + value = ff2.get ("uuid"); + test.is (value, "00000000-0000-0000-0000-000000000000", "ff4 uuid"); + value = ff2.get ("status"); + test.is (value, "pending", "ff4 status"); + test.ok (ff2.hasTag ("tag1"), "ff4 tag1"); + test.ok (ff2.hasTag ("tag2"), "ff4 tag2"); + test.is (ff2.getTagCount (), 2, "ff4 # tags"); + value = ff4.get ("att1"); + test.is (value, "value1", "ff4 att1"); + value = ff4.get ("att2"); + test.is (value, "value2", "ff4 att2"); + value = ff4.get ("description"); + test.is (value, "Description", "ff4 description"); + +/* + +TODO Task::composeCSV +TODO Task::id +TODO Task::*Status +TODO Task::*Tag* +TODO Task::*Annotation* + +*/ + + // Task::operator== + Task left ("[one:1 two:2 three:3]"); + Task right (left); + test.ok (left == right, "left == right -> true"); + left.set ("one", "1.0"); + test.notok (left == right, "left == right -> false"); + + // Task::validate + Task bad ("[entry:1000000001 start:1000000000]"); + good = true; + try { bad.validate (); } catch (...) { good = false; } + test.notok (good, "Task::validate entry <= start"); return 0; } src/tests/t.t.cpp @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 9; +use Test::More tests => 10; # Create the rc file. if (open my $fh, '>', 'tag.rc') @@ -39,20 +39,20 @@ if (open my $fh, '>', 'tag.rc') } # Add task with tags. -my $output = qx{../task rc:tag.rc add +1 This +2 is a test +3; ../task rc:tag.rc info 1}; -like ($output, qr/^Tags\s+1 2 3\n/m, 'tags found'); +my $output = qx{../task rc:tag.rc add +one This +two is a test +three; ../task rc:tag.rc info 1}; +like ($output, qr/^Tags\s+one two three\n/m, 'tags found'); # Remove tags. -$output = qx{../task rc:tag.rc 1 -3 -2 -1; ../task rc:tag.rc info 1}; -unlike ($output, qr/^Tags/m, '-3 -2 -1 tag removed'); +$output = qx{../task rc:tag.rc 1 -three -two -one; ../task rc:tag.rc info 1}; +unlike ($output, qr/^Tags/m, '-three -two -one tag removed'); # Add tags. -$output = qx{../task rc:tag.rc 1 +4 +5 +6; ../task rc:tag.rc info 1}; -like ($output, qr/^Tags\s+4 5 6\n/m, 'tags found'); +$output = qx{../task rc:tag.rc 1 +four +five +six; ../task rc:tag.rc info 1}; +like ($output, qr/^Tags\s+four five six\n/m, 'tags found'); # Remove tags. -$output = qx{../task rc:tag.rc 1 -4 -5 -6; ../task rc:tag.rc info 1}; -unlike ($output, qr/^Tags/m, '-4 -5 -6 tag removed'); +$output = qx{../task rc:tag.rc 1 -four -five -six; ../task rc:tag.rc info 1}; +unlike ($output, qr/^Tags/m, '-four -five -six tag removed'); # Add and remove tags. $output = qx{../task rc:tag.rc 1 +duplicate -duplicate; ../task rc:tag.rc info 1}; @@ -66,6 +66,9 @@ unlike ($output, qr/^Tags/m, '-missing NOP'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'tag.rc'; ok (!-r 'tag.rc', 'Removed tag.rc'); src/tests/tag.t @@ -27,90 +27,117 @@ #include <iostream> #include <unistd.h> -#include "../TDB.h" -#include "../task.h" +#include "main.h" #include "test.h" +Context context; + +//////////////////////////////////////////////////////////////////////////////// +void get (std::vector <Task>& pending, std::vector <Task>& completed) +{ + TDB tdb; + tdb.location ("."); + tdb.lock (); + tdb.loadPending (pending, context.filter); + tdb.loadCompleted (completed, context.filter); + tdb.unlock (); +} + //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { - UnitTest t (38); + UnitTest t (22); try { // Remove any residual test file. unlink ("./pending.data"); unlink ("./completed.data"); + unlink ("./undo.data"); // Try reading an empty database. + Filter filter; + std::vector <Task> all; + std::vector <Task> pending; + std::vector <Task> completed; + get (pending, completed); + t.ok (pending.size () == 0, "TDB Read empty pending"); + t.ok (completed.size () == 0, "TDB Read empty completed"); + + // Add without commit. TDB tdb; - tdb.dataDirectory ("."); - std::vector <T> all; - t.ok (!tdb.pendingT (all), "TDB::pendingT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (!tdb.allPendingT (all), "TDB::allPendingT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (!tdb.completedT (all), "TDB::completedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (!tdb.allCompletedT (all), "TDB::allCompletedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - - // Add a new task. - T t1; - t1.setId (1); - t1.setStatus (T::pending); - t1.setAttribute ("project", "p1"); - t1.setDescription ("task 1"); - t.diag (t1.compose ()); - t.ok (tdb.addT (t1), "TDB::addT t1"); - - // Verify as above. - t.ok (tdb.pendingT (all), "TDB::pendingT read db"); - t.is ((int) all.size (), 1, "empty db"); - t.ok (tdb.allPendingT (all), "TDB::allPendingT read db"); - t.is ((int) all.size (), 1, "empty db"); - t.ok (!tdb.completedT (all), "TDB::completedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (!tdb.allCompletedT (all), "TDB::allCompletedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - - // TODO Modify task. - - // Complete task. - t1.setStatus (T::completed); - t.ok (tdb.modifyT (t1), "TDB::modifyT (completed) t1");; - t.ok (tdb.pendingT (all), "TDB::pendingT read db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (tdb.allPendingT (all), "TDB::allPendingT read db"); - t.is ((int) all.size (), 1, "empty db"); - t.ok (!tdb.completedT (all), "TDB::completedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (!tdb.allCompletedT (all), "TDB::allCompletedT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - - t.is (tdb.gc (), 1, "TDB::gc"); - t.ok (tdb.pendingT (all), "TDB::pendingT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (tdb.allPendingT (all), "TDB::allPendingT read empty db"); - t.is ((int) all.size (), 0, "empty db"); - t.ok (tdb.completedT (all), "TDB::completedT read db"); - t.is ((int) all.size (), 1, "empty db"); - t.ok (tdb.allCompletedT (all), "TDB::allCompletedT read db"); - t.is ((int) all.size (), 1, "empty db"); - - // Add a new task. - T t2; - t2.setId (1); - t2.setAttribute ("project", "p2"); - t2.setDescription ("task 2"); - t.ok (tdb.addT (t2), "TDB::addT t2"); - - // Delete task. - t2.setStatus (T::deleted); - t.ok (tdb.modifyT (t2), "TDB::modifyT (deleted) t2"); - - // GC the files. - t.is (tdb.gc (), 1, "1 <- TDB::gc"); + tdb.location ("."); + tdb.lock (); + Task task ("[name:\"value\"]"); + tdb.add (task); + tdb.unlock (); + + pending.clear (); + completed.clear (); + get (pending, completed); + t.ok (pending.size () == 0, "TDB add -> no commit -> empty"); + t.ok (completed.size () == 0, "TDB add -> no commit -> empty"); + + // Add with commit. + tdb.lock (); + tdb.add (task); + tdb.commit (); + tdb.unlock (); + + get (pending, completed); + t.ok (pending.size () == 1, "TDB add -> commit -> saved"); + t.is (pending[0].get ("name"), "value", "TDB load name=value"); + t.is (pending[0].id, 1, "TDB load verification id=1"); + t.ok (completed.size () == 0, "TDB add -> commit -> saved"); + + // Update with commit. + tdb.lock (); + pending.clear (); + completed.clear (); + tdb.load (all, context.filter); + all[0].set ("name", "value2"); + tdb.update (all[0]); + tdb.commit (); + tdb.unlock (); + + pending.clear (); + completed.clear (); + get (pending, completed); + t.ok (all.size () == 1, "TDB update -> commit -> saved"); + t.is (all[0].get ("name"), "value2", "TDB load name=value2"); + t.is (all[0].id, 1, "TDB load verification id=1"); + + // GC. + tdb.lock (); + all.clear (); + tdb.loadPending (all, context.filter); + all[0].setStatus (Task::completed); + tdb.update (all[0]); + Task t2 ("[foo:\"bar\" status:\"pending\"]"); + tdb.add (t2); + tdb.commit (); + tdb.unlock (); + + pending.clear (); + completed.clear (); + get (pending, completed); + t.is (pending.size (), (size_t)2, "TDB before gc pending #2"); + t.is (pending[0].id, 1, "TDB before gc pending id 1"); + t.is (pending[0].getStatus (), Task::completed, "TDB before gc pending status completed"); + t.is (pending[1].id, 2, "TDB before gc pending id 2"); + t.is (pending[1].getStatus (), Task::pending, "TDB before gc pending status pending"); + t.is (completed.size (), (size_t)0, "TDB before gc completed 0"); + + tdb.gc (); + + pending.clear (); + completed.clear (); + get (pending, completed); + t.is (pending.size (), (size_t)1, "TDB after gc pending #1"); + t.is (pending[0].id, 1, "TDB after gc pending id 2"); + t.is (pending[0].getStatus (), Task::pending, "TDB after gc pending status pending"); + t.is (completed.size (), (size_t)1, "TDB after gc completed #1"); + t.is (completed[0].getStatus (), Task::completed, "TDB after gc completed status completed"); } catch (std::string& error) @@ -127,6 +154,7 @@ int main (int argc, char** argv) unlink ("./pending.data"); unlink ("./completed.data"); + unlink ("./undo.data"); return 0; } src/tests/tdb.t.cpp @@ -26,8 +26,10 @@ //////////////////////////////////////////////////////////////////////////////// #include <iostream> #include <iomanip> -#include <string> -#include <task.h> +#include <string.h> +#include <main.h> +#include <util.h> +#include <text.h> #include "test.h" /////////////////////////////////////////////////////////////////////////////// src/tests/test.cpp @@ -25,13 +25,16 @@ // //////////////////////////////////////////////////////////////////////////////// #include <iostream> -#include "task.h" +#include "main.h" +#include "text.h" #include "test.h" +Context context; + //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { - UnitTest t (94); + UnitTest t (109); // void wrapText (std::vector <std::string>& lines, const std::string& text, const int width) std::string text = "This is a test of the line wrapping code."; @@ -227,6 +230,27 @@ int main (int argc, char** argv) t.is (upperCase (""), "", "upperCase '' -> ''"); t.is (upperCase ("pre01_:POST"), "PRE01_:POST", "upperCase 'pre01_:POST' -> 'PRE01_:POST'"); + // bool digitsOnly (const std::string&); + t.ok (digitsOnly (""), "digitsOnly '' -> true"); + t.ok (digitsOnly ("0"), "digitsOnly '0' -> true"); + t.ok (digitsOnly ("123"), "digitsOnly '123' -> true"); + t.notok (digitsOnly ("12fa"), "digitsOnly '12fa' -> false"); + + // bool noSpaces (const std::string&); + t.ok (noSpaces (""), "noSpaces '' -> true"); + t.ok (noSpaces ("a"), "noSpaces 'a' -> true"); + t.ok (noSpaces ("abc"), "noSpaces 'abc' -> true"); + t.notok (noSpaces (" "), "noSpaces ' ' -> false"); + t.notok (noSpaces ("ab cd"), "noSpaces 'ab cd' -> false"); + + // bool noVerticalSpace (const std::string&); + t.ok (noVerticalSpace (""), "noVerticalSpace '' -> true"); + t.ok (noVerticalSpace ("a"), "noVerticalSpace 'a' -> true"); + t.ok (noVerticalSpace ("abc"), "noVerticalSpace 'abc' -> true"); + t.notok (noVerticalSpace ("a\nb"), "noVerticalSpace 'a\\nb' -> false"); + t.notok (noVerticalSpace ("a\rb"), "noVerticalSpace 'a\\rb' -> false"); + t.notok (noVerticalSpace ("a\fb"), "noVerticalSpace 'a\\fb' -> false"); + return 0; } src/tests/text.t.cpp @@ -45,18 +45,14 @@ ok (-r 'pending.data', 'pending.data created'); like ($output, qr/Status\s+Pending\n/, 'Pending'); $output = qx{../task rc:undo.rc do 1; ../task rc:undo.rc info 1}; -ok (! -r 'completed.data', 'completed.data not created'); +ok (-r 'completed.data', 'completed.data created'); like ($output, qr/Status\s+Completed\n/, 'Completed'); -$output = qx{../task rc:undo.rc undo 1; ../task rc:undo.rc info 1}; -ok (! -r 'completed.data', 'completed.data not created'); +$output = qx{echo 'y'|../task rc:undo.rc undo; ../task rc:undo.rc info 1}; +ok (-r 'completed.data', 'completed.data created'); like ($output, qr/Status\s+Pending\n/, 'Pending'); $output = qx{../task rc:undo.rc do 1; ../task rc:undo.rc list}; -like ($output, qr/^No matches/, 'No matches'); - -$output = qx{../task rc:undo.rc undo 1; ../task rc:undo.rc info 1}; -like ($output, qr/Task 1 not found/, 'Task 1 not found'); like ($output, qr/No matches/, 'No matches'); # Cleanup. @@ -68,6 +64,10 @@ ok (-r 'completed.data', 'Need to remove completed.data'); unlink 'completed.data'; ok (!-r 'completed.data', 'Removed completed.data'); +ok (-r 'undo.data', 'Need to remove undo.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'undo.rc'; ok (!-r 'undo.rc', 'Removed undo.rc'); src/tests/undo.t @@ -28,7 +28,7 @@ use strict; use warnings; -use Test::More tests => 6; +use Test::More tests => 7; # Create the rc file. if (open my $fh, '>', 'utf8.rc') @@ -73,6 +73,9 @@ like ($output, qr/utf8 in tag/, 'utf8 in tag works'); unlink 'pending.data'; ok (!-r 'pending.data', 'Removed pending.data'); +unlink 'undo.data'; +ok (!-r 'undo.data', 'Removed undo.data'); + unlink 'utf8.rc'; ok (!-r 'utf8.rc', 'Removed utf8.rc'); src/tests/utf8.t @@ -27,7 +27,12 @@ #include <iostream> #include <vector> #include <string> -#include "task.h" +#include <ctype.h> +#include "Context.h" +#include "util.h" +#include "text.h" + +extern Context context; static const char* newline = "\n"; static const char* noline = ""; @@ -292,12 +297,84 @@ std::string upperCase (const std::string& input) } //////////////////////////////////////////////////////////////////////////////// -const char* optionalBlankLine (Config& conf) +std::string ucFirst (const std::string& input) +{ + std::string output = input; + + if (output.length () > 0) + output[0] = ::toupper (output[0]); + + return output; +} + +//////////////////////////////////////////////////////////////////////////////// +const char* optionalBlankLine () { - if (conf.get ("blanklines", true) == true) + if (context.config.get ("blanklines", true) == true) // no i18n return newline; return noline; } //////////////////////////////////////////////////////////////////////////////// +void guess ( + const std::string& type, + std::vector<std::string>& options, + std::string& candidate) +{ + std::vector <std::string> matches; + autoComplete (candidate, options, matches); + if (1 == matches.size ()) + candidate = matches[0]; + + else if (0 == matches.size ()) + candidate = ""; + + else + { + std::string error = "Ambiguous "; // TODO i18n + error += type; + error += " '"; + error += candidate; + error += "' - could be either of "; // TODO i18n + for (size_t i = 0; i < matches.size (); ++i) + { + if (i) + error += ", "; + error += matches[i]; + } + + throw error; + } +} + +//////////////////////////////////////////////////////////////////////////////// +bool digitsOnly (const std::string& input) +{ + for (size_t i = 0; i < input.length (); ++i) + if (!::isdigit (input[i])) + return false; + + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +bool noSpaces (const std::string& input) +{ + for (size_t i = 0; i < input.length (); ++i) + if (::isspace (input[i])) + return false; + + return true; +} + +//////////////////////////////////////////////////////////////////////////////// +bool noVerticalSpace (const std::string& input) +{ + if (input.find_first_of ("\n\r\f") != std::string::npos) + return false; + + return true; +} + +//////////////////////////////////////////////////////////////////////////////// src/text.cpp @@ -26,6 +26,7 @@ //////////////////////////////////////////////////////////////////////////////// #include <iostream> #include <fstream> +#include <sstream> #include <vector> #include <string> #include <sys/types.h> @@ -36,15 +37,20 @@ #include <string.h> #include <pwd.h> #include <errno.h> + #include "Date.h" -#include "Table.h" -#include "task.h" +#include "text.h" +#include "main.h" +#include "i18n.h" +#include "util.h" #include "../auto.h" +extern Context context; + //////////////////////////////////////////////////////////////////////////////// // Uses std::getline, because std::cin eats leading whitespace, and that means // that if a newline is entered, std::cin eats it and never returns from the -// "std::cin >> answer;" line, but it does disply the newline. This way, with +// "std::cin >> answer;" line, but it does display the newline. This way, with // std::getline, the newline can be detected, and the prompt re-written. bool confirm (const std::string& question) { @@ -52,18 +58,55 @@ bool confirm (const std::string& question) do { - std::cout << question << " (y/n) "; + std::cout << question + << " " + << context.stringtable.get (CONFIRM_YES_NO, "(y/n)") + << " "; + std::getline (std::cin, answer); answer = lowerCase (trim (answer)); - if (answer == "\n") std::cout << "newline\n"; } - while (answer != "y" && - answer != "ye" && - answer != "yes" && - answer != "n" && - answer != "no"); + while (answer != "y" && // TODO i18n + answer != "ye" && // TODO i18n + answer != "yes" && // TODO i18n + answer != "n" && // TODO i18n + answer != "no"); // TODO i18n - return (answer == "y" || answer == "ye" || answer == "yes") ? true : false; + return (answer == "y" || answer == "ye" || answer == "yes") ? true : false; // TODO i18n +} + +//////////////////////////////////////////////////////////////////////////////// +// 0 = no +// 1 = yes +// 2 = all +int confirm3 (const std::string& question) +{ + std::vector <std::string> options; + options.push_back ("yes"); + options.push_back ("no"); + options.push_back ("all"); + + std::string answer; + std::vector <std::string> matches; + + do + { + std::cout << question + << " (" + << options[0] << "/" + << options[1] << "/" + << options[2] + << ") "; + + std::getline (std::cin, answer); + answer = trim (answer); + autoComplete (answer, options, matches); + } + while (matches.size () != 1); + + if (matches[0] == "yes") return 1; + else if (matches[0] == "all") return 2; + else return 0; } //////////////////////////////////////////////////////////////////////////////// @@ -78,121 +121,102 @@ void delay (float f) //////////////////////////////////////////////////////////////////////////////// // Convert a quantity in seconds to a more readable format. -// Long version: -// 0-59 S seconds -// 60-3599 M minutes, S seconds -// 3600-86399 H hours, M minutes, S seconds -// 86400- D days, H hours, M minutes, S seconds -// Short version: -// 0-59 S seconds -// 60-3599 M minutes, S seconds -// 3600-86399 H hours, M minutes, S seconds -// -void formatTimeDeltaDays (std::string& output, time_t delta) +std::string formatSeconds (time_t delta) { char formatted[24]; float days = (float) delta / 86400.0; if (days > 365) - sprintf (formatted, "%.1f yrs", (days / 365.2422)); + sprintf (formatted, "%.1f yrs", (days / 365.2422)); // TODO i18n else if (days > 84) - sprintf (formatted, "%1d mth%s", + sprintf (formatted, "%1d mth%s", // TODO i18n (int) (days / 30.6), - ((int) (days / 30.6) == 1 ? "" : "s")); + ((int) (days / 30.6) == 1 ? "" : "s")); // TODO i18n else if (days > 13) - sprintf (formatted, "%d wk%s", + sprintf (formatted, "%d wk%s", // TODO i18n (int) (days / 7.0), - ((int) (days / 7.0) == 1 ? "" : "s")); - else if (days > 5.0) - sprintf (formatted, "%d day%s", - (int) days, - ((int) days == 1 ? "" : "s")); + ((int) (days / 7.0) == 1 ? "" : "s")); // TODO i18n else if (days > 1.0) - sprintf (formatted, "%.1f days", days); + sprintf (formatted, "%d day%s", // TODO i18n + (int) days, + ((int) days == 1 ? "" : "s")); // TODO i18n else if (days * 24 > 1.0) - sprintf (formatted, "%d hr%s", + sprintf (formatted, "%d hr%s", // TODO i18n (int) (days * 24.0), - ((int) (days * 24.0) == 1 ? "" : "s")); + ((int) (days * 24) == 1 ? "" : "s")); // TODO i18n else if (days * 24 * 60 > 1) - sprintf (formatted, "%d min%s", + sprintf (formatted, "%d min%s", // TODO i18n (int) (days * 24 * 60), - ((int) (days * 24 * 60) == 1 ? "" : "s")); + ((int) (days * 24 * 60) == 1 ? "" : "s")); // TODO i18n else if (days * 24 * 60 * 60 > 1) - sprintf (formatted, "%d sec%s", + sprintf (formatted, "%d sec%s", // TODO i18n (int) (days * 24 * 60 * 60), - ((int) (days * 24 * 60 * 60) == 1 ? "" : "s")); + ((int) (days * 24 * 60 * 60) == 1 ? "" : "s")); // TODO i18n else - strcpy (formatted, "-"); + strcpy (formatted, "-"); // no i18n - output = formatted; + return std::string (formatted); } //////////////////////////////////////////////////////////////////////////////// -std::string formatSeconds (time_t delta) +// Convert a quantity in seconds to a more readable format. +std::string formatSecondsCompact (time_t delta) { char formatted[24]; float days = (float) delta / 86400.0; - if (days > 365) - sprintf (formatted, "%.1f yrs", (days / 365.2422)); - else if (days > 84) - sprintf (formatted, "%1d mth%s", - (int) (days / 30.6), - ((int) (days / 30.6) == 1 ? "" : "s")); - else if (days > 13) - sprintf (formatted, "%d wk%s", - (int) (days / 7.0), - ((int) (days / 7.0) == 1 ? "" : "s")); - else if (days > 5.0) - sprintf (formatted, "%d day%s", - (int) days, - ((int) days == 1 ? "" : "s")); - else if (days > 1.0) - sprintf (formatted, "%.1f days", days); - else if (days * 24 > 1.0) - sprintf (formatted, "%d hr%s", - (int) (days * 24.0), - ((int) (days * 24) == 1 ? "" : "s")); - else if (days * 24 * 60 > 1) - sprintf (formatted, "%d min%s", - (int) (days * 24 * 60), - ((int) (days * 24 * 60) == 1 ? "" : "s")); - else if (days * 24 * 60 * 60 > 1) - sprintf (formatted, "%d sec%s", - (int) (days * 24 * 60 * 60), - ((int) (days * 24 * 60 * 60) == 1 ? "" : "s")); + if (days > 365) sprintf (formatted, "%.1fy", (days / 365.2422)); // TODO i18n + else if (days > 84) sprintf (formatted, "%1dmo", (int) (days / 30.6)); // TODO i18n + else if (days > 13) sprintf (formatted, "%dwk", (int) (days / 7.0)); // TODO i18n + else if (days > 1.0) sprintf (formatted, "%dd", (int) days); // TODO i18n + else if (days * 24 > 1.0) sprintf (formatted, "%dh", (int) (days * 24.0)); // TODO i18n + else if (days * 24 * 60 > 1) sprintf (formatted, "%dm", (int) (days * 24 * 60)); // TODO i18n + else if (days * 24 * 3600 > 1) sprintf (formatted, "%ds", (int) (days * 24 * 60 * 60)); // TODO i18n else - strcpy (formatted, "-"); + strcpy (formatted, "-"); // no i18n return std::string (formatted); } //////////////////////////////////////////////////////////////////////////////// +// Convert a quantity in seconds to a more readable format. +std::string formatBytes (size_t bytes) +{ + char formatted[24]; + + if (bytes >= 995000000) sprintf (formatted, "%.1f GiB", (bytes / 1000000000.0)); + else if (bytes >= 995000) sprintf (formatted, "%.1f MiB", (bytes / 1000000.0)); + else if (bytes >= 995) sprintf (formatted, "%.1f KiB", (bytes / 1000.0)); + else sprintf (formatted, "%d B", (int)bytes ); + + return commify (formatted); +} + +//////////////////////////////////////////////////////////////////////////////// int autoComplete ( const std::string& partial, const std::vector<std::string>& list, std::vector<std::string>& matches) { - matches.erase (matches.begin (), matches.end ()); + matches.clear (); // Handle trivial case. unsigned int length = partial.length (); if (length) { - for (unsigned int i = 0; i < list.size (); ++i) + foreach (item, list) { - // Special case where there is an exact match. - if (partial == list[i]) + if (partial == *item) { - matches.erase (matches.begin (), matches.end ()); - matches.push_back (list[i]); + matches.clear (); + matches.push_back (*item); return 1; } // Maintain a list of partial matches. - if (length <= list[i].length () && - ! strncmp (partial.c_str (), list[i].c_str (), length)) - matches.push_back (list[i]); + if (length <= item->length () && + partial == item->substr (0, length)) + matches.push_back (*item); } } @@ -219,12 +243,10 @@ const std::string uuid () //////////////////////////////////////////////////////////////////////////////// #else -#warning "Using custom UUID generator" - #include <stdlib.h> static char randomHexDigit () { - static char digits[] = "0123456789abcdef"; + static char digits[] = "0123456789abcdef"; // no i18n #ifdef HAVE_RANDOM // random is better than rand. return digits[random () % 16]; @@ -281,74 +303,7 @@ const std::string uuid () #endif //////////////////////////////////////////////////////////////////////////////// -// Recognize the following constructs, and return the number of days represented -int convertDuration (const std::string& input) -{ - std::string lower_input = lowerCase (input); - Date today; - - std::vector <std::string> supported; - supported.push_back ("daily"); - supported.push_back ("day"); - supported.push_back ("weekly"); - supported.push_back ("weekdays"); - supported.push_back ("sennight"); - supported.push_back ("biweekly"); - supported.push_back ("fortnight"); - supported.push_back ("monthly"); - supported.push_back ("bimonthly"); - supported.push_back ("quarterly"); - supported.push_back ("biannual"); - supported.push_back ("biyearly"); - supported.push_back ("annual"); - supported.push_back ("semiannual"); - supported.push_back ("yearly"); - - std::vector <std::string> matches; - if (autoComplete (lower_input, supported, matches) == 1) - { - std::string found = matches[0]; - - if (found == "daily" || found == "day") return 1; - else if (found == "weekdays") return 1; - else if (found == "weekly" || found == "sennight") return 7; - else if (found == "biweekly" || found == "fortnight") return 14; - else if (found == "monthly") return 30; - else if (found == "bimonthly") return 61; - else if (found == "quarterly") return 91; - else if (found == "semiannual") return 183; - else if (found == "yearly" || found == "annual") return 365; - else if (found == "biannual" || found == "biyearly") return 730; - } - - // Support \d+ d|w|m|q|y - else - { - // Verify all digits followed by d, w, m, q, or y. - unsigned int length = lower_input.length (); - for (unsigned int i = 0; i < length; ++i) - { - if (! isdigit (lower_input[i]) && - i == length - 1) - { - int number = ::atoi (lower_input.substr (0, i).c_str ()); - - switch (lower_input[length - 1]) - { - case 'd': return number * 1; break; - case 'w': return number * 7; break; - case 'm': return number * 30; break; - case 'q': return number * 91; break; - case 'y': return number * 365; break; - } - } - } - } - - return 0; // Error. -} - -//////////////////////////////////////////////////////////////////////////////// +// no i18n std::string expandPath (const std::string& in) { std::string copy = in; @@ -468,7 +423,122 @@ void spit (const std::string& file, const std::string& contents) out.close (); } else - throw std::string ("Could not write file '") + file + "'"; + throw std::string ("Could not write file '") + file + "'"; // TODO i18n +} + +//////////////////////////////////////////////////////////////////////////////// +void spit ( + const std::string& file, + const std::vector <std::string>& lines, + bool addNewlines /* = true */) +{ + std::ofstream out (file.c_str ()); + if (out.good ()) + { + foreach (line, lines) + { + out << *line; + + if (addNewlines) + out << "\n"; + } + + out.close (); + } + else + throw std::string ("Could not write file '") + file + "'"; // TODO i18n +} + +//////////////////////////////////////////////////////////////////////////////// +bool taskDiff (const Task& before, const Task& after) +{ + // Attributes are all there is, so figure the different attribute names + // between before and after. + std::vector <std::string> beforeAtts; + foreach (att, before) + beforeAtts.push_back (att->first); + + std::vector <std::string> afterAtts; + foreach (att, after) + afterAtts.push_back (att->first); + + std::vector <std::string> beforeOnly; + std::vector <std::string> afterOnly; + listDiff (beforeAtts, afterAtts, beforeOnly, afterOnly); + + if (beforeOnly.size () || + afterOnly.size ()) + return true; + + foreach (name, beforeAtts) + if (*name != "uuid" && + before.get (*name) != after.get (*name)) + return true; + + return false; +} + +//////////////////////////////////////////////////////////////////////////////// +std::string taskDifferences (const Task& before, const Task& after) +{ + // Attributes are all there is, so figure the different attribute names + // between before and after. + std::vector <std::string> beforeAtts; + foreach (att, before) + beforeAtts.push_back (att->first); + + std::vector <std::string> afterAtts; + foreach (att, after) + afterAtts.push_back (att->first); + + std::vector <std::string> beforeOnly; + std::vector <std::string> afterOnly; + listDiff (beforeAtts, afterAtts, beforeOnly, afterOnly); + + // Now start generating a description of the differences. + std::stringstream out; + foreach (name, beforeOnly) + out << " - " + << *name + << " was deleted\n"; + + foreach (name, afterOnly) + out << " - " + << *name + << " was set to '" + << renderAttribute (*name, after.get (*name)) + << "'\n"; + + foreach (name, beforeAtts) + if (*name != "uuid" && + after.get (*name) != "" && + before.get (*name) != after.get (*name)) + out << " - " + << *name + << " was changed from '" + << renderAttribute (*name, before.get (*name)) + << "' to '" + << renderAttribute (*name, after.get (*name)) + << "'\n"; + + // Shouldn't just say nothing. + if (out.str ().length () == 0) + out << " - No changes were made\n"; + + return out.str (); +} + +//////////////////////////////////////////////////////////////////////////////// +std::string renderAttribute (const std::string& name, const std::string& value) +{ + Att a; + if (a.type (name) == "date") + { + Date d ((time_t)::atoi (value.c_str ())); + return d.toString (context.config.get ("dateformat", "m/d/Y")); + } + + return value; } //////////////////////////////////////////////////////////////////////////////// src/util.cpp DEVELOPERS Makefile.in binary/COPYING.txt binary/README.txt checklist.txt doc/man1/task.1 doc/man5/taskrc.5 grammar.bnf html/30second.html html/advanced.html html/color.html html/config.html html/custom.html html/date.html html/faq.html html/filter.html html/git.html html/images/color.png html/import.html html/links.html html/recur.html html/sequence.html html/setup.html html/shadow.html html/shell.html html/simple.html html/tab_completion.html html/task.css html/task.html html/versions.html script.txt src/Makefile.in src/T.cpp src/T.h src/parse.cpp src/task.cpp src/task.h src/tests/parse.t.cpp task.pmdoc/01task-contents.xml task.pmdoc/01task.xml task.pmdoc/index.xml task_completion.sh 1422a15cbc470cff590bf06daad20d01fe1b05ef 14977ef317bd004dae2f2c313e806af9f2a2140c Paul Beckingham paul@beckingham.net http://github.com/pbeckingham/task/commit/90d53245c3c57422ff5003eefe04fea2c24bbd02 90d53245c3c57422ff5003eefe04fea2c24bbd02 2009-07-21T16:15:54-07:00 2009-07-21T16:15:54-07:00 Merge branch '1.8.0' Conflicts: .gitignore AUTHORS ChangeLog DEVELOPERS Makefile.am NEWS README configure.ac doc/man/task.1 doc/man/taskrc.5 src/T.cpp src/T.h src/TDB.cpp src/TDB.h src/command.cpp src/edit.cpp src/import.cpp src/parse.cpp src/report.cpp src/rules.cpp src/task.cpp src/task.h task_completion.sh 114a6ecbfe18251f366f7c651e0a4eda0d1e79ec Paul Beckingham paul@beckingham.net