GothenburgBitFactory/taskwarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/taskwarrior.git synced 2025-08-28 13:37:20 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Enhancement - next

Browse source 
- The next report is now a custom report.  There is also a nasty
  piece of logic that lets the next report exist as a custom report,
  and also with it's own handleReportNext function to prep and filter
  the tasks, then hand off to runCustomReport.
This commit is contained in:
Paul Beckingham 2009-06-25 00:47:07 -04:00
parent f31f068322
commit a32263e7ea
7 changed files with 134 additions and 199 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/Cmd.cpp
View file

@ -147,12 +147,19 @@ void Cmd::load ()
if (i->substr (0, 7) == "report.") if (i->substr (0, 7) == "report.")
{ {
std::string report = i->substr (7, std::string::npos); std::string report = i->substr (7, std::string::npos);
// Oh, what a massive hack. Shame. Shame.
// The "next" report is in limbo between being a built-in report and
// a custom report. The projection is defined as a custom report, but
// the restriction is different.
if (report.substr (0, 4) == "next")
continue;
std::string::size_type columns = report.find (".columns"); std::string::size_type columns = report.find (".columns");
if (columns != std::string::npos) if (columns != std::string::npos)
{ {
report = report.substr (0, columns); report = report.substr (0, columns);
// Make sure a custom report does not clash with a built-in // Make sure a custom report does not clash with a built-in
// command. // command.
if (std::find (commands.begin (), commands.end (), report) != commands.end ()) if (std::find (commands.begin (), commands.end (), report) != commands.end ())

22
src/Config.cpp
View file

@ -224,6 +224,17 @@ void Config::createDefault (const std::string& home)
fprintf (out, "report.waiting.sort=wait+,priority-,project+\n"); // TODO i18n fprintf (out, "report.waiting.sort=wait+,priority-,project+\n"); // TODO i18n
fprintf (out, "report.waiting.filter=status:waiting\n"); // TODO i18n fprintf (out, "report.waiting.filter=status:waiting\n"); // TODO i18n
fprintf (out, "report.all.description=Lists all tasks matching the specified criteria\n"); // TODO i18n
fprintf (out, "report.all.columns=id,project,priority,due,active,age,description\n"); // TODO i18n
fprintf (out, "report.all.labels=ID,Project,Pri,Due,Active,Age,Description\n"); // TODO i18n
fprintf (out, "report.all.sort=due+,priority-,project+\n"); // TODO i18n
fprintf (out, "report.next.description=Lists all tasks matching the specified criteria\n"); // TODO i18n
fprintf (out, "report.next.columns=id,project,priority,due,active,age,description\n"); // TODO i18n
fprintf (out, "report.next.labels=ID,Project,Pri,Due,Active,Age,Description\n"); // TODO i18n
fprintf (out, "report.next.sort=due+,priority-,project+\n"); // TODO i18n
fprintf (out, "report.next.filter=status:pending\n"); // TODO i18n
fclose (out); fclose (out);
std::cout << "Done." << std::endl; // TODO i18n std::cout << "Done." << std::endl; // TODO i18n
@ -302,6 +313,17 @@ void Config::setDefaults ()
set ("report.waiting.labels", "ID,Project,Pri,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.sort", "wait+,priority-,project+"); // TODO i18n
set ("report.waiting.filter", "status:waiting"); // 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 all tasks matching the specified criteria"); // 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
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////

16
src/TDB.cpp
View file

@ -382,19 +382,6 @@ int TDB::commit ()
return quantity; return quantity;
} }
////////////////////////////////////////////////////////////////////////////////
// TODO -> FF4
void TDB::upgrade ()
{
// TODO Read all pending
// TODO Write out all pending
// TODO Read all completed
// TODO Write out all completed
throw std::string ("unimplemented TDB::upgrade");
}
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Scans the pending tasks for any that are completed or deleted, and if so, // 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. // moves them to the completed.data file. Returns a count of tasks moved.
@ -435,7 +422,10 @@ int TDB::gc ()
// Wake up tasks that are waiting. // Wake up tasks that are waiting.
Date wait_date (::atoi (task->get ("wait").c_str ())); Date wait_date (::atoi (task->get ("wait").c_str ()));
if (now > wait_date) if (now > wait_date)
{
task->setStatus (Task::pending); task->setStatus (Task::pending);
task->remove ("wait");
}
still_pending.push_back (*task); still_pending.push_back (*task);
} }

1
src/TDB.h
View file

@ -59,7 +59,6 @@ public:
void add (const Task&); // Single task add to pending void add (const Task&); // Single task add to pending
void update (const Task&); // Single task update to pending void update (const Task&); // Single task update to pending
int commit (); // Write out all tasks int commit (); // Write out all tasks
void upgrade (); // Convert both files to FF4
int gc (); // Clean up pending int gc (); // Clean up pending
int nextId (); int nextId ();

2
src/main.h
View file

@ -45,7 +45,7 @@ void validSortColumns (const std::vector <std::string>&, const std::vector <std:
bool validTag (const std::string&); bool validTag (const std::string&);
// task.cpp // task.cpp
void gatherNextTasks (std::vector <Task>&, std::vector <int>&); void gatherNextTasks (std::vector <Task>&);
void onChangeCallback (); void onChangeCallback ();
// recur.cpp // recur.cpp

282
src/report.cpp
View file

@ -679,138 +679,50 @@ std::string handleReportSummary ()
// //
std::string handleReportNext () std::string handleReportNext ()
{ {
// 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");
std::vector <std::string> filterArgs;
split (filterArgs, filterList, ' ');
{
Cmd cmd ("next");
Task task;
Sequence sequence;
Subst subst;
Filter filter;
context.parse (filterArgs, cmd, task, sequence, subst, filter);
context.sequence.combine (sequence);
// Allow limit to be overridden by the command line.
if (!context.task.has ("limit") && task.has ("limit"))
context.task.set ("limit", task.get ("limit"));
foreach (att, filter)
context.filter.push_back (*att);
}
// Get all the tasks. // Get all the tasks.
std::vector <Task> tasks; std::vector <Task> tasks;
context.tdb.lock (context.config.get ("locking", true)); context.tdb.lock (context.config.get ("locking", true));
handleRecurrence (); handleRecurrence ();
context.tdb.loadPending (tasks, context.filter); context.tdb.load (tasks, context.filter);
context.tdb.commit (); context.tdb.commit ();
context.tdb.unlock (); context.tdb.unlock ();
// Restrict to matching subset. // Restrict to matching subset.
std::vector <int> matching; gatherNextTasks (tasks);
gatherNextTasks (tasks, matching);
initializeColorRules (); return runCustomReport (
"next",
// Create a table for output. columnList,
Table table; labelList,
table.setTableWidth (context.getWidth ()); sortList,
table.setDateFormat (context.config.get ("dateformat", "m/d/Y")); filterList,
table.addColumn ("ID"); tasks);
table.addColumn ("Project");
table.addColumn ("Pri");
table.addColumn ("Due");
table.addColumn ("Active");
table.addColumn ("Age");
table.addColumn ("Description");
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);
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);
// Iterate over each task, and apply selection criteria.
foreach (i, matching)
{
Date now;
// Now format the matching task.
bool imminent = false;
bool overdue = false;
std::string due = tasks[*i].get ("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 (context.config.get ("dateformat", "m/d/Y"));
}
std::string active;
if (tasks[*i].has ("start"))
active = "*";
std::string age;
std::string created = tasks[*i].get ("entry");
if (created.length ())
{
Date dt (::atoi (created.c_str ()));
age = formatSeconds ((time_t) (now - dt));
}
// All criteria match, so add tasks[*i] to the output table.
int row = table.addRow ();
table.addCell (row, 0, tasks[*i].id);
table.addCell (row, 1, tasks[*i].get ("project"));
table.addCell (row, 2, tasks[*i].get ("priority"));
table.addCell (row, 3, due);
table.addCell (row, 4, active);
table.addCell (row, 5, age);
table.addCell (row, 6, getFullDescription (tasks[*i]));
if (context.config.get ("color", true) || context.config.get (std::string ("_forcecolor"), false))
{
Text::color fg = Text::colorCode (tasks[*i].get ("fg"));
Text::color bg = Text::colorCode (tasks[*i].get ("bg"));
autoColorize (tasks[*i], fg, bg);
table.setRowFg (row, fg);
table.setRowBg (row, bg);
if (fg == Text::nocolor)
{
if (overdue)
table.setCellFg (row, 3, Text::colorCode (context.config.get ("color.overdue", "red")));
else if (imminent)
table.setCellFg (row, 3, Text::colorCode (context.config.get ("color.due", "yellow")));
}
}
}
std::stringstream out;
if (table.rowCount ())
out << optionalBlankLine ()
<< table.render ()
<< optionalBlankLine ()
<< table.rowCount ()
<< (table.rowCount () == 1 ? " task" : " tasks")
<< std::endl;
else
out << "No matches."
<< std::endl;
return out.str ();
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -1848,34 +1760,33 @@ std::string handleReportStats ()
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void gatherNextTasks ( void gatherNextTasks (std::vector <Task>& tasks)
std::vector <Task>& tasks,
std::vector <int>& all)
{ {
// For counting tasks by project. // For counting tasks by project.
std::map <std::string, int> countByProject; std::map <std::string, int> countByProject;
std::map <int, bool> matching; std::map <int, bool> matching;
std::vector <Task> filtered;
Date now; Date now;
// How many items per project? Default 3. // How many items per project? Default 3.
int limit = context.config.get ("next", 3); int limit = context.config.get ("next", 3);
// due:< 1wk, pri:* // due:< 1wk, pri:*
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
if (tasks[i].has ("due")) if (task->has ("due"))
{ {
Date d (::atoi (tasks[i].get ("due").c_str ())); Date d (::atoi (task->get ("due").c_str ()));
if (d < now + (7 * 24 * 60 * 60)) // if due:< 1wk if (d < now + (7 * 24 * 60 * 60)) // if due:< 1wk
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
@ -1883,20 +1794,21 @@ void gatherNextTasks (
} }
// due:*, pri:H // due:*, pri:H
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
if (tasks[i].has ("due")) if (task->has ("due"))
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "H") if (priority == "H")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
@ -1904,38 +1816,40 @@ void gatherNextTasks (
} }
// pri:H // pri:H
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "H") if (priority == "H")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
} }
// due:*, pri:M // due:*, pri:M
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
if (tasks[i].has ("due")) if (task->has ("due"))
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "M") if (priority == "M")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
@ -1943,38 +1857,40 @@ void gatherNextTasks (
} }
// pri:M // pri:M
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "M") if (priority == "M")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
} }
// due:*, pri:L // due:*, pri:L
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
if (tasks[i].has ("due")) if (task->has ("due"))
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "L") if (priority == "L")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
@ -1982,47 +1898,47 @@ void gatherNextTasks (
} }
// pri:L // pri:L
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "L") if (priority == "L")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
} }
// due:, pri: // due:, pri:
for (unsigned int i = 0; i < tasks.size (); ++i) foreach (task, tasks)
{ {
if (tasks[i].getStatus () == Task::pending) if (task->getStatus () == Task::pending)
{ {
if (tasks[i].has ("due")) if (task->has ("due"))
{ {
std::string priority = tasks[i].get ("priority"); std::string priority = task->get ("priority");
if (priority == "") if (priority == "")
{ {
std::string project = tasks[i].get ("project"); std::string project = task->get ("project");
if (countByProject[project] < limit && matching.find (i) == matching.end ()) if (countByProject[project] < limit && matching.find (task->id) == matching.end ())
{ {
++countByProject[project]; ++countByProject[project];
matching[i] = true; matching[task->id] = true;
filtered.push_back (*task);
} }
} }
} }
} }
} }
// Convert map to vector. tasks = filtered;
foreach (i, matching)
all.push_back (i->first);
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

1
src/tests/.gitignore vendored
View file

@ -15,3 +15,4 @@ subst.t
filt.t filt.t
cmd.t cmd.t
config.t config.t
*.log