int main (int argc, char** argv)
{
UnitTest t (19);
// TODO bool confirm (const std::string&);
// TODO int confirm3 (const std::string&);
// TODO int confirm4 (const std::string&);
// TODO void delay (float);
// std::string formatBytes (size_t);
t.is (formatBytes (0), "0 B", "0 -> 0 B");
t.is (formatBytes (994), "994 B", "994 -> 994 B");
t.is (formatBytes (995), "1.0 KiB", "995 -> 1.0 KiB");
t.is (formatBytes (999), "1.0 KiB", "999 -> 1.0 KiB");
t.is (formatBytes (1000), "1.0 KiB", "1000 -> 1.0 KiB");
t.is (formatBytes (1001), "1.0 KiB", "1001 -> 1.0 KiB");
t.is (formatBytes (999999), "1.0 MiB", "999999 -> 1.0 MiB");
t.is (formatBytes (1000000), "1.0 MiB", "1000000 -> 1.0 MiB");
t.is (formatBytes (1000001), "1.0 MiB", "1000001 -> 1.0 MiB");
t.is (formatBytes (999999999), "1.0 GiB", "999999999 -> 1.0 GiB");
t.is (formatBytes (1000000000), "1.0 GiB", "1000000000 -> 1.0 GiB");
t.is (formatBytes (1000000001), "1.0 GiB", "1000000001 -> 1.0 GiB");
// TODO const std::string uuid ();
// std::string taskDiff (const Task&, const Task&);
Task left;
left.set ("zero", "0");
left.set ("one", 1);
left.set ("two", 2);
Task right;
right.set ("zero", "00");
right.set ("two", 2);
right.set ("three", 3);
Task rightAgain (right);
std::string output = taskDifferences (left, right);
t.ok (taskDiff (left, right), "Detected changes");
t.ok (output.find ("zero will be changed from '0' to '00'") != std::string::npos, "Detected change zero:0 -> zero:00");
t.ok (output.find ("one will be deleted") != std::string::npos, "Detected deletion one:1 ->");
t.ok (output.find ("two") == std::string::npos, "Detected no change two:2 -> two:2");
t.ok (output.find ("three will be set to '3'") != std::string::npos, "Detected addition -> three:3");
t.notok (taskDiff (right, rightAgain), "No changes detected");
output = taskDifferences (right, rightAgain);
t.ok (output.find ("No changes will be made") != std::string::npos, "No changes detected");
return 0;
}
int CmdModify::execute (std::string& output)
{
int rc = 0;
int count = 0;
// Apply filter.
Filter filter;
std::vector <Task> filtered;
filter.subset (filtered);
if (filtered.size () == 0)
{
context.footnote (STRING_FEEDBACK_NO_TASKS_SP);
return 1;
}
// TODO Complain when no modifications are specified.
// Accumulated project change notifications.
std::map <std::string, std::string> projectChanges;
std::vector <Task>::iterator task;
for (task = filtered.begin (); task != filtered.end (); ++task)
{
Task before (*task);
task->modify (Task::modReplace);
if (taskDiff (before, *task))
{
// Perform some logical consistency checks.
if (task->has ("recur") &&
!task->has ("due") &&
!before.has ("due"))
throw std::string (STRING_CMD_MODIFY_NO_DUE);
if (before.has ("recur") &&
before.has ("due") &&
(!task->has ("due") ||
task->get ("due") == ""))
throw std::string (STRING_CMD_MODIFY_REM_DUE);
if (before.has ("recur") &&
(!task->has ("recur") ||
task->get ("recur") == ""))
throw std::string (STRING_CMD_MODIFY_REC_ALWAYS);
// Delete the specified task.
std::string question;
if (task->id != 0)
question = format (STRING_CMD_MODIFY_CONFIRM,
task->id,
task->get ("description"));
else
question = format (STRING_CMD_MODIFY_CONFIRM,
task->get ("uuid"),
task->get ("description"));
if (permission (*task, taskDifferences (before, *task) + question, filtered.size ()))
{
updateRecurrenceMask (*task);
dependencyChainOnModify (before, *task);
++count;
feedback_affected (STRING_CMD_MODIFY_TASK, *task);
feedback_unblocked (*task);
context.tdb2.modify (*task);
if (context.verbose ("project"))
projectChanges[task->get ("project")] = onProjectChange (before, *task);
// Task potentially has siblings - modify them.
if (task->has ("parent"))
{
if ((context.config.get ("recurrence.confirmation") == "prompt"
&& confirm (STRING_CMD_MODIFY_RECUR)) ||
context.config.getBoolean ("recurrence.confirmation"))
{
std::vector <Task> siblings = context.tdb2.siblings (*task);
std::vector <Task>::iterator sibling;
for (sibling = siblings.begin (); sibling != siblings.end (); ++sibling)
{
Task alternate (*sibling);
sibling->modify (Task::modReplace);
updateRecurrenceMask (*sibling);
dependencyChainOnModify (alternate, *sibling);
++count;
feedback_affected (STRING_CMD_MODIFY_TASK_R, *sibling);
feedback_unblocked (*sibling);
context.tdb2.modify (*sibling);
if (context.verbose ("project"))
projectChanges[sibling->get ("project")] = onProjectChange (alternate, *sibling);
}
// Modify the parent
Task parent;
context.tdb2.get (task->get ("parent"), parent);
parent.modify (Task::modReplace);
context.tdb2.modify (parent);
}
}
// Task potentially has child tasks - modify them.
else if (task->get ("status") == "recurring")
{
std::vector <Task> children = context.tdb2.children (*task);
if (children.size () &&
(! context.config.getBoolean ("recurrence.confirmation") ||
confirm (STRING_CMD_MODIFY_RECUR)))
{
std::vector <Task>::iterator child;
for (child = children.begin (); child != children.end (); ++child)
{
Task alternate (*child);
child->modify (Task::modReplace);
updateRecurrenceMask (*child);
context.tdb2.modify (*child);
dependencyChainOnModify (alternate, *child);
if (context.verbose ("project"))
projectChanges[child->get ("project")] = onProjectChange (alternate, *child);
++count;
feedback_affected (STRING_CMD_MODIFY_TASK_R, *child);
}
}
}
}
else
{
std::cout << STRING_CMD_MODIFY_NO << "\n";
rc = 1;
if (_permission_quit)
break;
}
}
}
// Now list the project changes.
std::map <std::string, std::string>::iterator i;
for (i = projectChanges.begin (); i != projectChanges.end (); ++i)
if (i->first != "")
context.footnote (i->second);
feedback_affected (count == 1 ? STRING_CMD_MODIFY_1 : STRING_CMD_MODIFY_N, count);
return rc;
}
int main (int argc, char** argv)
{
UnitTest t (40);
// TODO bool confirm (const std::string&);
// TODO int confirm3 (const std::string&);
// TODO int confirm4 (const std::string&);
// TODO void delay (float);
// std::string formatBytes (size_t);
t.is (formatBytes (0), "0 B", "0 -> 0 B");
t.is (formatBytes (994), "994 B", "994 -> 994 B");
t.is (formatBytes (995), "1.0 KiB", "995 -> 1.0 KiB");
t.is (formatBytes (999), "1.0 KiB", "999 -> 1.0 KiB");
t.is (formatBytes (1000), "1.0 KiB", "1000 -> 1.0 KiB");
t.is (formatBytes (1001), "1.0 KiB", "1001 -> 1.0 KiB");
t.is (formatBytes (999999), "1.0 MiB", "999999 -> 1.0 MiB");
t.is (formatBytes (1000000), "1.0 MiB", "1000000 -> 1.0 MiB");
t.is (formatBytes (1000001), "1.0 MiB", "1000001 -> 1.0 MiB");
t.is (formatBytes (999999999), "1.0 GiB", "999999999 -> 1.0 GiB");
t.is (formatBytes (1000000000), "1.0 GiB", "1000000000 -> 1.0 GiB");
t.is (formatBytes (1000000001), "1.0 GiB", "1000000001 -> 1.0 GiB");
// TODO const std::string uuid ();
// TODO These are in feedback.cpp, not util.cpp.
// std::string taskDiff (const Task&, const Task&);
Task left;
left.set ("zero", "0");
left.set ("one", 1);
left.set ("two", 2);
Task right;
right.set ("zero", "00");
right.set ("two", 2);
right.set ("three", 3);
Task rightAgain (right);
std::string output = taskDifferences (left, right);
t.ok (taskDiff (left, right), "Detected changes");
t.ok (output.find ("Zero will be changed from '0' to '00'") != std::string::npos, "Detected change zero:0 -> zero:00");
t.ok (output.find ("One will be deleted") != std::string::npos, "Detected deletion one:1 ->");
t.ok (output.find ("Two") == std::string::npos, "Detected no change two:2 -> two:2");
t.ok (output.find ("Three will be set to '3'") != std::string::npos, "Detected addition -> three:3");
t.notok (taskDiff (right, rightAgain), "No changes detected");
output = taskDifferences (right, rightAgain);
t.ok (output.find ("No changes will be made") != std::string::npos, "No changes detected");
// void combine (std::vector <int>&, const std::vector <int>&);
std::vector <int> vleft;
vleft.push_back (1);
vleft.push_back (2);
vleft.push_back (3);
std::vector <int> vright;
vright.push_back (4);
combine (vleft, vright);
t.is (vleft.size (), (size_t)4, "1,2,3 + 4 -> [4]");
t.is (vleft[0], 1, "1,2,3 + 4 -> 1,2,3,4");
t.is (vleft[1], 2, "1,2,3 + 4 -> 1,2,3,4");
t.is (vleft[2], 3, "1,2,3 + 4 -> 1,2,3,4");
t.is (vleft[3], 4, "1,2,3 + 4 -> 1,2,3,4");
vright.push_back (3);
vright.push_back (5);
combine (vleft, vright);
t.is (vleft.size (), (size_t)5, "1,2,3,4 + 3,4,5 -> [5]");
t.is (vleft[0], 1, "1,2,3,4 + 3,4,5 -> 1,2,3,4,5");
t.is (vleft[1], 2, "1,2,3,4 + 3,4,5 -> 1,2,3,4,5");
t.is (vleft[2], 3, "1,2,3,4 + 3,4,5 -> 1,2,3,4,5");
t.is (vleft[3], 4, "1,2,3,4 + 3,4,5 -> 1,2,3,4,5");
t.is (vleft[4], 5, "1,2,3,4 + 3,4,5 -> 1,2,3,4,5");
// std::vector<std::string> indentTree (const std::vector<std::string>&, const std::string whitespace=" ", char delimiter='.');
std::vector <std::string> flat;
flat.push_back ("one");
flat.push_back ("one.two");
flat.push_back ("one.two.three");
flat.push_back ("one.four");
flat.push_back ("two");
std::vector <std::string> structured = indentTree (flat, " ", '.');
t.is (structured.size (), (size_t) 5, "indentTree yields 5 strings");
t.is (structured[0], "one", "indentTree 'one' -> 'one'");
t.is (structured[1], " one.two", "indentTree 'one.two' -> ' one.two'");
t.is (structured[2], " one.two.three", "indentTree 'one.two.three' -> ' one.two.three'");
t.is (structured[3], " one.four", "indentTree 'one.four' -> ' one.four'");
t.is (structured[4], "two", "indentTree 'two' -> 'two'");
// std::vector<std::string> indentProject (const std::string&, const std::string whitespace=" ", char delimiter='.');
t.is (indentProject (""), "", "indentProject '' -> ''");
t.is (indentProject ("one"), "one", "indentProject 'one' -> 'one'");
t.is (indentProject ("one.two"), " one.two", "indentProject 'one.two' -> ' one.two'");
t.is (indentProject ("one.two.three"), " one.two.three", "indentProject 'one.two.three' -> ' one.two.three'");
// TODO const std::string encode (const std::string& value);
// TODO const std::string decode (const std::string& value);
return 0;
}
