Merge branch 'master' of github.com:bram85/topydo

test/DeleteCommandTest.py

@@ -35,6 +35,8 @@ class DeleteCommandTest(CommandTest):
         todos = [
             "Foo id:1",
             "Bar p:1",
+            "a @test with due:2015-06-03",
+            "a @test with +project",
         ]
 
         self.todolist = TodoList(todos)
@@ -62,7 +64,7 @@ class DeleteCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.todolist.count(), 0)
+        self.assertEqual(self.todolist.count(), 2)
         self.assertEqual(self.output, "|  2| Bar p:1\nRemoved: Bar\nRemoved: Foo\n")
         self.assertEqual(self.errors, "")
 
@@ -71,7 +73,7 @@ class DeleteCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.todolist.count(), 1) # force won't delete subtasks
+        self.assertEqual(self.todolist.count(), 3) # force won't delete subtasks
         self.assertEqual(self.output, "|  2| Bar p:1\nRemoved: Foo id:1\n")
         self.assertEqual(self.errors, "")
 
@@ -80,7 +82,7 @@ class DeleteCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.todolist.count(), 1) # force won't delete subtasks
+        self.assertEqual(self.todolist.count(), 3) # force won't delete subtasks
         self.assertEqual(self.output, "|  2| Bar p:1\nRemoved: Foo id:1\n")
         self.assertEqual(self.errors, "")
 
@@ -116,7 +118,9 @@ class DeleteCommandTest(CommandTest):
         command = DeleteCommand(["8to"], self.todolist, self.out, self.error)
         command.execute()
 
-        self.assertEqual(self.todolist.print_todos(), "Foo")
+        result = "Foo\na @test with due:2015-06-03\na @test with +project"
+
+        self.assertEqual(self.todolist.print_todos(), result)
         self.assertRaises(InvalidTodoException, self.todolist.todo, 'b0n')
 
     def test_multi_del1(self):
@@ -124,14 +128,20 @@ class DeleteCommandTest(CommandTest):
         command = DeleteCommand(["1", "2"], self.todolist, self.out, self.error, _no_prompt)
         command.execute()
 
-        self.assertEqual(self.todolist.count(), 0)
+        result = "a @test with due:2015-06-03\na @test with +project"
+
+        self.assertEqual(self.todolist.count(), 2)
+        self.assertEqual(self.todolist.print_todos(), result)
 
     def test_multi_del2(self):
         """ Test deletion of multiple items. """
         command = DeleteCommand(["1", "2"], self.todolist, self.out, self.error, _yes_prompt)
         command.execute()
 
-        self.assertEqual(self.todolist.count(), 0)
+        result = "a @test with due:2015-06-03\na @test with +project"
+
+        self.assertEqual(self.todolist.count(), 2)
+        self.assertEqual(self.todolist.print_todos(), result)
 
     def test_multi_del3(self):
         """  Fail if any of supplied todo numbers is invalid. """
@@ -160,6 +170,50 @@ class DeleteCommandTest(CommandTest):
         self.assertEqual(self.output, "")
         self.assertEqual(self.errors, u("Invalid todo number given: Fo\u00d3B\u0105r.\n"))
 
+    def test_expr_del1(self):
+        command = DeleteCommand(["-e", "@test"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        result = "Removed: a @test with due:2015-06-03\nRemoved: a @test with +project\n"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.todolist.count(), 2)
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_del2(self):
+        command = DeleteCommand(["-e", "@test", "due:2015-06-03"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, "Removed: a @test with due:2015-06-03\n")
+        self.assertEqual(self.errors, "")
+
+    def test_expr_del3(self):
+        command = DeleteCommand(["-e", "@test", "due:2015-06-03", "+project"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_del4(self):
+        """ Remove only relevant todo items. """
+        command = DeleteCommand(["-e", ""], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        result = "Foo"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.todolist.count(), 1)
+        self.assertEqual(self.todolist.print_todos(), result)
+
+    def test_expr_del5(self):
+        """ Force deleting unrelevant items with additional -x flag. """
+        command = DeleteCommand(["-xe", ""], self.todolist, self.out, self.error, _yes_prompt)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.todolist.count(), 0)
+
     def test_empty(self):
         command = DeleteCommand([], self.todolist, self.out, self.error)
         command.execute()

test/DepriCommandTest.py

@@ -28,6 +28,9 @@ class DepriCommandTest(CommandTest):
             "(A) Foo",
             "Bar",
             "(B) Baz",
+            "(E) a @test with due:2015-06-03",
+            "(Z) a @test with +project p:1",
+            "(D) Bax id:1",
         ]
 
         self.todolist = TodoList(todos)
@@ -69,6 +72,50 @@ class DepriCommandTest(CommandTest):
         self.assertEqual(self.output, "Priority removed.\n|  1| Foo\nPriority removed.\n|  3| Baz\n")
         self.assertEqual(self.errors, "")
 
+    def test_expr_depri1(self):
+        command = DepriCommand(["-e", "@test"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+
+        result = "Priority removed.\n|  4| a @test with due:2015-06-03\nPriority removed.\n|  5| a @test with +project p:1\n"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_depri2(self):
+        command = DepriCommand(["-e", "@test", "due:2015-06-03"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        result = "Priority removed.\n|  4| a @test with due:2015-06-03\n"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_depri3(self):
+        command = DepriCommand(["-e", "@test", "due:2015-06-03", "+project"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_depri4(self):
+        """ Don't remove priority from unrelevant todo items. """
+        command = DepriCommand(["-e", "Bax"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_depri5(self):
+        """ Force unprioritizing unrelevant items with additional -x flag. """
+        command = DepriCommand(["-xe", "Bax"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, "Priority removed.\n|  6| Bax id:1\n")
+        self.assertEqual(self.errors, "")
+
+
 
     def test_invalid1(self):
         command = DepriCommand(["99"], self.todolist, self.out, self.error)

test/DoCommandTest.py

@@ -41,6 +41,8 @@ class DoCommandTest(CommandTest):
             "Subtodo of inactive p:2",
             "Strict due:2014-01-01 rec:1d",
             "Invalid rec:1",
+            "a @test with due:2015-06-03",
+            "a @test with +project",
         ]
 
         self.todolist = TodoList(todos)
@@ -123,7 +125,7 @@ class DoCommandTest(CommandTest):
 
         self.assertTrue(self.todolist.is_dirty())
         self.assertEqual(self.errors, "")
-        self.assertEqual(self.todolist.count(), 10)
+        self.assertEqual(self.todolist.count(), 12)
 
     def test_recurrence(self):
         self.assertFalse(self.todolist.todo(4).has_tag('due'))
@@ -131,7 +133,7 @@ class DoCommandTest(CommandTest):
         self._recurrence_helper(["4"])
 
         self.assertTrue(self.todolist.todo(4).is_completed())
-        result = "| 10| {today} Recurring! rec:1d due:{tomorrow}\nCompleted: x {today} Recurring! rec:1d\n".format(today=self.today, tomorrow=self.tomorrow)
+        result = "| 12| {today} Recurring! rec:1d due:{tomorrow}\nCompleted: x {today} Recurring! rec:1d\n".format(today=self.today, tomorrow=self.tomorrow)
         self.assertEqual(self.output, result)
 
         todo = self.todolist.todo(10)
@@ -140,13 +142,13 @@ class DoCommandTest(CommandTest):
 
     def test_strict_recurrence1(self):
         self._recurrence_helper(["-s", "8"])
-        result = "| 10| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {today} Strict due:2014-01-01 rec:1d\n".format(today=self.today)
+        result = "| 12| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {today} Strict due:2014-01-01 rec:1d\n".format(today=self.today)
         self.assertEqual(self.output, result)
 
     def test_strict_recurrence2(self):
         self._recurrence_helper(["--strict", "8"])
 
-        result = "| 10| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {today} Strict due:2014-01-01 rec:1d\n".format(today=self.today)
+        result = "| 12| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {today} Strict due:2014-01-01 rec:1d\n".format(today=self.today)
         self.assertEqual(self.output, result)
 
     def test_invalid1(self):
@@ -254,7 +256,7 @@ class DoCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.output, "| 10| {today} Recurring! rec:1d due:{today}\nCompleted: x {yesterday} Recurring! rec:1d\n".format(today=self.today, yesterday=self.yesterday))
+        self.assertEqual(self.output, "| 12| {today} Recurring! rec:1d due:{today}\nCompleted: x {yesterday} Recurring! rec:1d\n".format(today=self.today, yesterday=self.yesterday))
         self.assertEqual(self.errors, "")
 
     def test_do_custom_date6(self):
@@ -267,7 +269,7 @@ class DoCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.output, "| 10| {today} Recurring! rec:1d due:{today}\nCompleted: x {yesterday} Recurring! rec:1d\n".format(today=self.today, yesterday=self.yesterday))
+        self.assertEqual(self.output, "| 12| {today} Recurring! rec:1d due:{today}\nCompleted: x {yesterday} Recurring! rec:1d\n".format(today=self.today, yesterday=self.yesterday))
         self.assertEqual(self.errors, "")
 
     def test_do_custom_date7(self):
@@ -279,7 +281,7 @@ class DoCommandTest(CommandTest):
         command.execute()
 
         self.assertTrue(self.todolist.is_dirty())
-        self.assertEqual(self.output, "| 10| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {yesterday} Strict due:2014-01-01 rec:1d\n".format(today=self.today, yesterday=self.yesterday))
+        self.assertEqual(self.output, "| 12| {today} Strict due:2014-01-02 rec:1d\nCompleted: x {yesterday} Strict due:2014-01-01 rec:1d\n".format(today=self.today, yesterday=self.yesterday))
         self.assertEqual(self.errors, "")
 
     def test_multi_do1(self):
@@ -320,10 +322,10 @@ class DoCommandTest(CommandTest):
         """
         Check output when all supplied todo numbers are invalid.
         """
-        command = DoCommand(["99", "10"], self.todolist, self.out, self.error, _no_prompt)
+        command = DoCommand(["99", "15"], self.todolist, self.out, self.error, _no_prompt)
         command.execute()
 
-        self.assertEqual(self.errors, "Invalid todo number given: 99.\nInvalid todo number given: 10.\n")
+        self.assertEqual(self.errors, "Invalid todo number given: 99.\nInvalid todo number given: 15.\n")
 
     def test_multi_do6(self):
         """ Throw an error with invalid argument containing special characters. """
@@ -333,6 +335,46 @@ class DoCommandTest(CommandTest):
         self.assertFalse(self.todolist.is_dirty())
         self.assertEqual(self.errors, u("Invalid todo number given: Fo\u00d3B\u0105r.\n"))
 
+    def test_expr_do1(self):
+        command = DoCommand(["-e", "@test"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, "Completed: x {t} a @test with due:2015-06-03\nCompleted: x {t} a @test with +project\n".format(t=self.today))
+        self.assertEqual(self.errors, "")
+
+    def test_expr_do2(self):
+        command = DoCommand(["-e", "@test", "due:2015-06-03"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, "Completed: x {} a @test with due:2015-06-03\n".format(self.today))
+        self.assertEqual(self.errors, "")
+
+    def test_expr_do3(self):
+        command = DoCommand(["-e", "@test", "due:2015-06-03", "+project"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_do4(self):
+        """ Don't do anything with unrelevant todo items. """
+        command = DoCommand(["-e", "Foo"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_do5(self):
+        """ Force marking unrelevant items as done with additional -x flag. """
+        command = DoCommand(["-xe", "Foo"], self.todolist, self.out, self.error, _yes_prompt)
+        command.execute()
+
+        result = "|  2| Bar p:1\n|  3| Baz p:1\nCompleted: x {t} Bar p:1\nCompleted: x {t} Baz p:1\nCompleted: x {t} Foo id:1\n".format(t=self.today)
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
     def test_invalid_recurrence(self):
         """ Show error message when an item has an invalid recurrence pattern. """
         command = DoCommand(["9"], self.todolist, self.out, self.error, _no_prompt)

test/EditCommandTest.py

@@ -139,7 +139,7 @@ class EditCommandTest(CommandTest):
         self.assertEqual(self.output, expected)
         self.assertEqual(self.todolist.print_todos(), u("Foo id:1\nFo\u00f3B\u0105\u017a\nLazy Cat\nLazy Dog"))
 
-    @mock.patch('topydo.commands.EditCommand.call')
+    @mock.patch('topydo.commands.EditCommand.check_call')
     def test_edit_archive(self, mock_call):
         """ Edit archive file. """
         mock_call.return_value = 0
@@ -148,11 +148,29 @@ class EditCommandTest(CommandTest):
         os.environ['EDITOR'] = editor
         archive = config().archive()
 
-        command = EditCommand([u("-d")], self.todolist, self.out, self.error, None)
+        command = EditCommand(["-d"], self.todolist, self.out, self.error, None)
         command.execute()
 
         self.assertEqual(self.errors, "")
         mock_call.assert_called_once_with([editor, archive])
 
+    @mock.patch('topydo.commands.EditCommand.check_call')
+    def test_edit_todotxt(self, mock_call):
+        """ Edit todo file. """
+        mock_call.return_value = 0
+
+        editor = 'vi'
+        os.environ['EDITOR'] = editor
+        todotxt = config().todotxt()
+
+        result = self.todolist.print_todos() # copy TodoList content *before* executing command
+
+        command = EditCommand([], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertEqual(self.errors, "")
+        self.assertEqual(self.todolist.print_todos(), result)
+        mock_call.assert_called_once_with([editor, todotxt])
+
 if __name__ == '__main__':
     unittest.main()

test/PostponeCommandTest.py

@@ -37,6 +37,7 @@ class PostponeCommandTest(CommandTest):
             "Baz due:{} t:{}".format(self.today.isoformat(), self.start.isoformat()),
             "Past due:{}".format(self.past.isoformat()),
             "Future due:{} t:{}".format(self.future.isoformat(), self.future_start.isoformat()),
+            "FutureStart t:{}".format(self.future.isoformat())
         ]
 
         self.todolist = TodoList(todos)
@@ -233,6 +234,55 @@ class PostponeCommandTest(CommandTest):
         self.assertEqual(self.output, "")
         self.assertEqual(self.errors, u("Invalid todo number given: Fo\u00d3B\u0105r.\n"))
 
+    def test_expr_postpone1(self):
+        command = PostponeCommand(["-e", "due:tod", "2w"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        due = self.today + timedelta(14)
+        result = "|  2| Bar due:{d}\n|  3| Baz due:{d} t:{s}\n".format(d=due.isoformat(), s=self.start.isoformat())
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_postpone2(self):
+        cmd_args = ["-e", "t:{}".format(self.start.isoformat()), "due:tod", "1w"]
+        command = PostponeCommand(cmd_args, self.todolist, self.out, self.error, None)
+        command.execute()
+
+        due = self.today + timedelta(7)
+
+        result = "|  3| Baz due:{} t:{}\n".format(due.isoformat(), self.start.isoformat())
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_postpone3(self):
+        command = PostponeCommand(["-e", "@test", "due:tod", "+project", "C"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_postpone4(self):
+        """ Don't postpone unrelevant todo items. """
+        command = PostponeCommand(["-e", "FutureStart", "1w"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_postpone5(self):
+        """ Force postponing unrelevant items with additional -x flag. """
+        command = PostponeCommand(["-xe", "FutureStart", "1w"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        due = self.today + timedelta(7)
+        result = "|  6| FutureStart t:{} due:{}\n".format(self.future.isoformat(), due.isoformat())
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
     def test_help(self):
         command = PostponeCommand(["help"], self.todolist, self.out, self.error)
         command.execute()

test/PriorityCommandTest.py

@@ -27,6 +27,9 @@ class PriorityCommandTest(CommandTest):
         todos = [
             "(A) Foo",
             "Bar",
+            "(B) a @test with due:2015-06-03",
+            "a @test with +project p:1",
+            "Baz id:1",
         ]
 
         self.todolist = TodoList(todos)
@@ -71,6 +74,49 @@ class PriorityCommandTest(CommandTest):
         self.assertEqual(self.output, "Priority changed from A to C\n|  1| (C) Foo\nPriority set to C.\n|  2| (C) Bar\n")
         self.assertEqual(self.errors, "")
 
+    def test_expr_prio1(self):
+        command = PriorityCommand(["-e", "@test", "C"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+
+        result = "Priority changed from B to C\n|  3| (C) a @test with due:2015-06-03\nPriority set to C.\n|  4| (C) a @test with +project p:1\n"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_prio2(self):
+        command = PriorityCommand(["-e", "@test", "due:2015-06-03", "C"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        result = "Priority changed from B to C\n|  3| (C) a @test with due:2015-06-03\n"
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, result)
+        self.assertEqual(self.errors, "")
+
+    def test_expr_prio3(self):
+        command = PriorityCommand(["-e", "@test", "due:2015-06-03", "+project", "C"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_prio4(self):
+        """ Don't prioritize unrelevant todo items. """
+        command = PriorityCommand(["-e", "Baz", "C"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertFalse(self.todolist.is_dirty())
+
+    def test_expr_prio5(self):
+        """ Force prioritizing unrelevant items with additional -x flag. """
+        command = PriorityCommand(["-xe", "Baz", "D"], self.todolist, self.out, self.error, None)
+        command.execute()
+
+        self.assertTrue(self.todolist.is_dirty())
+        self.assertEqual(self.output, "Priority set to D.\n|  5| (D) Baz id:1\n")
+        self.assertEqual(self.errors, "")
+
     def test_invalid1(self):
         command = PriorityCommand(["99", "A"], self.todolist, self.out, self.error)
         command.execute()

topydo/commands/DeleteCommand.py

@@ -14,7 +14,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-from topydo.commands.DCommand import DCommand
+from topydo.lib.DCommand import DCommand
 
 class DeleteCommand(DCommand):
     def __init__(self, p_args, p_todolist,

topydo/commands/DepriCommand.py

@@ -25,20 +25,14 @@ class DepriCommand(MultiCommand):
         super(DepriCommand, self).__init__(
             p_args, p_todolist, p_out, p_err, p_prompt)
 
-        self.get_todos(self.args)
-
-    def execute_multi_specific(self):
-        try:
-            self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
-
-            for todo in self.todos:
-                if todo.priority() != None:
-                    self.todolist.set_priority(todo, None)
-                    self.out("Priority removed.")
-                    self.out(self.printer.print_todo(todo))
-
-        except IndexError:
-            self.error(self.usage())
+    def _execute_multi_specific(self):
+        self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
+
+        for todo in self.todos:
+            if todo.priority() != None:
+                self.todolist.set_priority(todo, None)
+                self.out("Priority removed.")
+                self.out(self.printer.print_todo(todo))
 
     def usage(self):
         return """Synopsis: depri <NUMBER1> [<NUMBER2> ...]"""

topydo/commands/DoCommand.py

@@ -16,7 +16,7 @@
 
 from datetime import date
 
-from topydo.commands.DCommand import DCommand
+from topydo.lib.DCommand import DCommand
 from topydo.lib.PrettyPrinter import PrettyPrinter
 from topydo.lib.PrettyPrinterFilter import PrettyPrinterNumbers
 from topydo.lib.Recurrence import advance_recurring_todo, strict_advance_recurring_todo, NoRecurrenceException
@@ -36,9 +36,13 @@ class DoCommand(DCommand):
 
     def get_flags(self):
         """ Additional flags. """
-        return ("d:s", ["date=", "strict"])
+        opts, long_opts = super(DoCommand, self).get_flags()
+
+        return ("d:s" + opts, ["date=", "strict"] + long_opts)
 
     def process_flag(self, p_opt, p_value):
+        super(DoCommand, self).process_flag(p_opt, p_value)
+
         if p_opt == "-s" or p_opt == "--strict":
             self.strict_recurrence = True
         elif p_opt == "-d" or p_opt == "--date":

topydo/commands/EditCommand.py

@@ -34,26 +34,25 @@ DEFAULT_EDITOR = 'vi'
 # cannot use super() inside the class itself
 BASE_TODOLIST = lambda tl: super(TodoList, tl)
 
-class EditCommand(MultiCommand, ExpressionCommand):
+class EditCommand(MultiCommand):
     def __init__(self, p_args, p_todolist, p_output, p_error, p_input):
         super(EditCommand, self).__init__(p_args, p_todolist, p_output,
             p_error, p_input)
 
+        if len(self.args) == 0:
+            self.multi_mode = False
+
         self.is_expression = False
         self.edit_archive = False
+        self.last_argument = False
 
-    def _process_flags(self):
-        opts, args = self.getopt('xed')
-
-        for opt, value in opts:
-            if opt == '-d':
-                self.edit_archive = True
-            elif opt == '-x':
-                self.show_all = True
-            elif opt == '-e':
-                self.is_expression = True
+    def get_flags(self):
+        return ("d", [])
 
-        self.args = args
+    def process_flag(self, p_opt, p_value):
+        if p_opt == '-d':
+            self.edit_archive = True
+            self.multi_mode = False
 
     def _todos_to_temp(self):
         f = tempfile.NamedTemporaryFile()
@@ -73,12 +72,20 @@ class EditCommand(MultiCommand, ExpressionCommand):
 
         return todo_objs
 
-    def _open_in_editor(self, p_temp_file, p_editor):
+    def _open_in_editor(self, p_file):
+        try:
+            editor = os.environ['EDITOR'] or DEFAULT_EDITOR
+        except(KeyError):
+            editor = DEFAULT_EDITOR
+
         try:
-            return check_call([p_editor, p_temp_file.name])
+            return check_call([editor, p_file])
         except CalledProcessError:
             self.error('Something went wrong in the editor...')
             return 1
+        except(OSError):
+            self.error('There is no such editor as: ' + editor + '. '
+                        'Check your $EDITOR and/or $PATH')
 
     def _catch_todo_errors(self):
         errors = []
@@ -94,59 +101,35 @@ class EditCommand(MultiCommand, ExpressionCommand):
         else:
             return None
 
-    def execute(self):
-        if not super(EditCommand, self).execute():
-            return False
-
+    def _execute_multi_specific(self):
         self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
-        try:
-            editor = os.environ['EDITOR'] or DEFAULT_EDITOR
-        except(KeyError):
-            editor = DEFAULT_EDITOR
 
-        try:
-            if len(self.args) < 1:
-                todo = config().todotxt()
+        temp_todos = self._todos_to_temp()
 
-                return call([editor, todo]) == 0
+        if not self._open_in_editor(temp_todos.name):
+            new_todos = self._todos_from_temp(temp_todos)
+            if len(new_todos) == len(self.todos):
+                for todo in self.todos:
+                    BASE_TODOLIST(self.todolist).delete(todo)
+
+                for todo in new_todos:
+                    self.todolist.add_todo(todo)
+                    self.out(self.printer.print_todo(todo))
             else:
-                self._process_flags()
-
-                if self.edit_archive:
-                    archive = config().archive()
-
-                    return call([editor, archive]) == 0
-
-                if self.is_expression:
-                    self.todos = self._view().todos
-                else:
-                    self.get_todos(self.args)
-
-                todo_errors = self._catch_todo_errors()
-
-                if not todo_errors:
-                    temp_todos = self._todos_to_temp()
-
-                    if not self._open_in_editor(temp_todos, editor):
-                        new_todos = self._todos_from_temp(temp_todos)
-                        if len(new_todos) == len(self.todos):
-                            for todo in self.todos:
-                                BASE_TODOLIST(self.todolist).delete(todo)
-
-                            for todo in new_todos:
-                                self.todolist.add_todo(todo)
-                                self.out(self.printer.print_todo(todo))
-                        else:
-                            self.error('Number of edited todos is not equal to '
-                                        'number of supplied todo IDs.')
-                    else:
-                        self.error(self.usage())
-                else:
-                    for error in todo_errors:
-                        self.error(error)
-        except(OSError):
-            self.error('There is no such editor as: ' + editor + '. '
-                        'Check your $EDITOR and/or $PATH')
+                self.error('Number of edited todos is not equal to '
+                            'number of supplied todo IDs.')
+        else:
+            self.error(self.usage())
+
+    def _execute_not_multi(self):
+        if self.edit_archive:
+            archive = config().archive()
+
+            return self._open_in_editor(archive) == 0
+        else:
+            todo = config().todotxt()
+
+            return self._open_in_editor(todo) == 0
 
     def usage(self):
         return """Synopsis:

topydo/commands/PostponeCommand.py

@@ -17,7 +17,6 @@
 from datetime import date, timedelta
 
 from topydo.lib.MultiCommand import MultiCommand
-from topydo.lib.Command import InvalidCommandArgument
 from topydo.lib.Config import config
 from topydo.lib.PrettyPrinterFilter import PrettyPrinterNumbers
 from topydo.lib.RelativeDate import relative_date_to_date
@@ -32,19 +31,16 @@ class PostponeCommand(MultiCommand):
             p_args, p_todolist, p_out, p_err, p_prompt)
 
         self.move_start_date = False
-        self._process_flags()
-        self.get_todos(self.args[:-1])
+        self.last_argument = True
 
-    def _process_flags(self):
-        opts, args = self.getopt('s')
+    def get_flags(self):
+        return("s", [])
 
-        for opt, _ in opts:
-            if opt == '-s':
-                self.move_start_date = True
+    def process_flag(self, p_opt, p_value):
+        if p_opt == '-s':
+            self.move_start_date = True
 
-        self.args = args
-
-    def execute_multi_specific(self):
+    def _execute_multi_specific(self):
         def _get_offset(p_todo):
             offset = p_todo.tag_value(
                 config().tag_due(), date.today().isoformat())
@@ -55,31 +51,28 @@ class PostponeCommand(MultiCommand):
 
             return offset_date
 
-        try:
-            pattern = self.args[-1]
-            self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
-
-            for todo in self.todos:
-                offset = _get_offset(todo)
-                new_due = relative_date_to_date(pattern, offset)
+        pattern = self.args[-1]
+        self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
 
-                if new_due:
-                    if self.move_start_date and todo.has_tag(config().tag_start()):
-                        length = todo.length()
-                        new_start = new_due - timedelta(length)
-                        # pylint: disable=E1103
-                        todo.set_tag(config().tag_start(), new_start.isoformat())
+        for todo in self.todos:
+            offset = _get_offset(todo)
+            new_due = relative_date_to_date(pattern, offset)
 
+            if new_due:
+                if self.move_start_date and todo.has_tag(config().tag_start()):
+                    length = todo.length()
+                    new_start = new_due - timedelta(length)
                     # pylint: disable=E1103
-                    todo.set_tag(config().tag_due(), new_due.isoformat())
-
-                    self.todolist.set_dirty()
-                    self.out(self.printer.print_todo(todo))
-                else:
-                    self.error("Invalid date pattern given.")
-                    break
-        except (InvalidCommandArgument, IndexError):
-            self.error(self.usage())
+                    todo.set_tag(config().tag_start(), new_start.isoformat())
+
+                # pylint: disable=E1103
+                todo.set_tag(config().tag_due(), new_due.isoformat())
+
+                self.todolist.set_dirty()
+                self.out(self.printer.print_todo(todo))
+            else:
+                self.error("Invalid date pattern given.")
+                break
 
     def usage(self):
         return "Synopsis: postpone [-s] <NUMBER> [<NUMBER2> ...] <PATTERN>"

topydo/commands/PriorityCommand.py

@@ -26,31 +26,28 @@ class PriorityCommand(MultiCommand):
         super(PriorityCommand, self).__init__(
             p_args, p_todolist, p_out, p_err, p_prompt)
 
-        self.get_todos(self.args[:-1])
+        self.last_argument = True
 
-    def execute_multi_specific(self):
+    def _execute_multi_specific(self):
         priority = None
 
-        try:
-            priority = self.args[-1]
-            self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
-
-            if is_valid_priority(priority):
-                for todo in self.todos:
-                    old_priority = todo.priority()
-                    self.todolist.set_priority(todo, priority)
-
-                    if old_priority and priority and old_priority != priority:
-                        self.out("Priority changed from {} to {}".format(
-                            old_priority, priority))
-                    elif not old_priority:
-                        self.out("Priority set to {}.".format(priority))
-
-                    self.out(self.printer.print_todo(todo))
-            else:
-                self.error("Invalid priority given.")
-        except IndexError:
-            self.error(self.usage())
+        priority = self.args[-1]
+        self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
+
+        if is_valid_priority(priority):
+            for todo in self.todos:
+                old_priority = todo.priority()
+                self.todolist.set_priority(todo, priority)
+
+                if old_priority and priority and old_priority != priority:
+                    self.out("Priority changed from {} to {}".format(
+                        old_priority, priority))
+                elif not old_priority:
+                    self.out("Priority set to {}.".format(priority))
+
+                self.out(self.printer.print_todo(todo))
+        else:
+            self.error("Invalid priority given.")
 
     def usage(self):
         return """Synopsis: pri <NUMBER1> [<NUMBER2> ...] <PRIORITY>"""

topydo/commands/DCommand.py → topydo/lib/DCommand.py

@@ -35,29 +35,14 @@ class DCommand(MultiCommand):
 
         self.force = False
 
-        self.process_flags()
         self.length = len(self.todolist.todos()) # to determine newly activated todos
-        self.get_todos(self.args)
 
     def get_flags(self):
-        """ Default implementation of getting specific flags. """
-        return ("", [])
+        return ("f", ["force"])
 
-    def process_flag(self, p_option, p_value):
-        """ Default implementation of processing specific flags. """
-        pass
-
-    def process_flags(self):
-        opts, args = self.get_flags()
-        opts, args = self.getopt("f" + opts, ["force"] + args)
-
-        for opt, value in opts:
-            if opt == "-f" or opt == "--force":
-                self.force = True
-            else:
-                self.process_flag(opt, value)
-
-        self.args = args
+    def process_flag(self, p_opt, p_value):
+        if p_opt == "-f" or p_opt == "--force":
+            self.force = True
 
     def _uncompleted_children(self, p_todo):
         return sorted(
@@ -128,7 +113,7 @@ class DCommand(MultiCommand):
         """
         pass
 
-    def execute_multi_specific(self):
+    def _execute_multi_specific(self):
         old_active = self._active_todos()
 
         for todo in self.todos:

topydo/lib/ExpressionCommand.py

@@ -35,13 +35,22 @@ class ExpressionCommand(Command):
 
         self.sort_expression = config().sort_string()
         self.show_all = False
+        # Commands using last argument differently (i.e as something other than
+        # todo ID/expression) have to set attribute below to True.
+        self.last_argument = False
 
     def _filters(self):
         filters = []
 
         def arg_filters():
             result = []
-            for arg in self.args:
+
+            if self.last_argument:
+                args = self.args[:-1]
+            else:
+                args = self.args
+
+            for arg in args:
                 if re.match(Filter.ORDINAL_TAG_MATCH, arg):
                     argfilter = Filter.OrdinalTagFilter(arg)
                 elif len(arg) > 1 and arg[0] == '-':

topydo/lib/MultiCommand.py

@@ -16,10 +16,10 @@
 
 from six import u
 
-from topydo.lib.Command import Command
+from topydo.lib.ExpressionCommand import ExpressionCommand
 from topydo.lib.TodoListBase import InvalidTodoException
 
-class MultiCommand(Command):
+class MultiCommand(ExpressionCommand):
     """
     A common class for operations that can work with multiple todo IDs.
     """
@@ -33,14 +33,49 @@ class MultiCommand(Command):
 
         self.todos = []
         self.invalid_numbers = []
+        self.is_expression = False
+        self.multi_mode = True
 
-    def get_todos(self, p_numbers):
+    def get_flags(self):
+        """ Default implementation of getting specific flags. """
+        return ("", [])
+
+    def process_flag(self, p_option, p_value):
+        """ Default implementation of processing specific flags. """
+        pass
+
+    def _process_flags(self):
+        opts, long_opts = self.get_flags()
+        opts, args = self.getopt("xe" + opts, long_opts)
+
+        for opt, value in opts:
+            if opt == '-x':
+                self.show_all = True
+            elif opt == '-e':
+                self.is_expression = True
+            else:
+                self.process_flag(opt, value)
+
+        self.args = args
+
+    def get_todos_from_expr(self):
+        self.todos = self._view().todos
+
+    def get_todos(self):
         """ Gets todo objects from supplied todo IDs """
-        for number in p_numbers:
-            try:
-                self.todos.append(self.todolist.todo(number))
-            except InvalidTodoException:
-                self.invalid_numbers.append(number)
+        if self.is_expression:
+            self.get_todos_from_expr()
+        else:
+            if self.last_argument:
+                numbers = self.args[:-1]
+            else:
+                numbers = self.args
+
+            for number in numbers:
+                try:
+                    self.todos.append(self.todolist.todo(number))
+                except InvalidTodoException:
+                    self.invalid_numbers.append(number)
 
     def _catch_todo_errors(self):
         """
@@ -65,23 +100,36 @@ class MultiCommand(Command):
         else:
             return None
 
-    def execute_multi_specific(self):
+    def _execute_multi_specific(self):
         """
         Operations specific for particular command dealing with multiple todo
         IDs.
         """
         pass
 
+    def _execute_not_multi(self):
+        """
+        Some commands can do something else besides operating on multiple todo
+        IDs. This method is a wrapper for those other operations.
+        """
+        pass
+
     def execute(self):
         if not super(MultiCommand, self).execute():
             return False
 
-        todo_errors = self._catch_todo_errors()
+        self._process_flags()
 
-        if not todo_errors:
-            self.execute_multi_specific()
+        if not self.multi_mode:
+            self._execute_not_multi()
         else:
-            for error in todo_errors:
-                self.error(error)
+            self.get_todos()
+            todo_errors = self._catch_todo_errors()
+
+            if not todo_errors:
+                self._execute_multi_specific()
+            else:
+                for error in todo_errors:
+                    self.error(error)
 
         return True