GNOME.org
 

[pitivi] undo: Use is_in_transaction to simplify signals

commit ecd0ad021ad714fc17e2e18dcf8d181f2d394711
Author: Alexandru Băluț <alexandru balut gmail com>
Date:   Sun Apr 3 05:23:57 2016 +0200

    undo: Use is_in_transaction to simplify signals
    
    The passed "nested" value was used in a single place actually.
    It's more clear to query directly the action log.
    
    Differential Revision: https://phabricator.freedesktop.org/D857

 pitivi/application.py       |    4 +-
 pitivi/undo/undo.py         |   26 ++++++++-----------
 tests/test_undo.py          |   56 +++++++++++++++++++++---------------------
 tests/test_undo_timeline.py |    2 +-
 4 files changed, 42 insertions(+), 46 deletions(-)
---
diff --git a/pitivi/application.py b/pitivi/application.py
index eb9a699..511569c 100644
--- a/pitivi/application.py
+++ b/pitivi/application.py
@@ -352,8 +352,8 @@ class Pitivi(Gtk.Application, Loggable):
     def _redoCb(self, unused_action, unused_param):
         self.action_log.redo()
 
-    def _actionLogCommit(self, action_log, unused_stack, nested):
-        if nested:
+    def _actionLogCommit(self, action_log, unused_stack):
+        if action_log.is_in_transaction():
             return
         self._syncDoUndo(action_log)
 
diff --git a/pitivi/undo/undo.py b/pitivi/undo/undo.py
index 824073b..5d31321 100644
--- a/pitivi/undo/undo.py
+++ b/pitivi/undo/undo.py
@@ -143,10 +143,10 @@ class UndoableActionLog(GObject.Object, Loggable):
     only one instance of it in Pitivi: application.py's "action_log" property.
     """
     __gsignals__ = {
-        "begin": (GObject.SIGNAL_RUN_LAST, None, (object, bool)),
+        "begin": (GObject.SIGNAL_RUN_LAST, None, (object,)),
         "push": (GObject.SIGNAL_RUN_LAST, None, (object, object)),
-        "rollback": (GObject.SIGNAL_RUN_LAST, None, (object, bool)),
-        "commit": (GObject.SIGNAL_RUN_LAST, None, (object, bool)),
+        "rollback": (GObject.SIGNAL_RUN_LAST, None, (object,)),
+        "commit": (GObject.SIGNAL_RUN_LAST, None, (object,)),
         "undo": (GObject.SIGNAL_RUN_LAST, None, (object,)),
         "redo": (GObject.SIGNAL_RUN_LAST, None, (object,)),
         "cleaned": (GObject.SIGNAL_RUN_LAST, None, ()),
@@ -167,17 +167,15 @@ class UndoableActionLog(GObject.Object, Loggable):
         self._checkpoint = self._takeSnapshot()
 
     def begin(self, action_group_name, finalizing_action=None):
-        self.debug("Beginning %s", action_group_name)
         if self.running:
             self.debug("Abort because already running")
             return
 
         stack = UndoableActionStack(action_group_name, finalizing_action)
-        nested = self._stackIsNested(stack)
         self.stacks.append(stack)
         self.debug("begin action group %s, nested %s",
-                   stack.action_group_name, nested)
-        self.emit("begin", stack, nested)
+                   stack.action_group_name, len(self.stacks))
+        self.emit("begin", stack)
 
     def push(self, action):
         self.debug("Pushing %s", action)
@@ -213,10 +211,9 @@ class UndoableActionLog(GObject.Object, Loggable):
         stack = self._getTopmostStack(pop=True)
         if stack is None:
             return
-        nested = self._stackIsNested(stack)
         self.debug("rollback action group %s, nested %s",
-                   stack.action_group_name, nested)
-        self.emit("rollback", stack, nested)
+                   stack.action_group_name, len(self.stacks))
+        self.emit("rollback", stack)
         stack.undo()
 
     def commit(self):
@@ -228,7 +225,6 @@ class UndoableActionLog(GObject.Object, Loggable):
         stack = self._getTopmostStack(pop=True)
         if stack is None:
             return
-        nested = self._stackIsNested(stack)
         if not self.stacks:
             self.undo_stacks.append(stack)
         else:
@@ -238,8 +234,8 @@ class UndoableActionLog(GObject.Object, Loggable):
             self.redo_stacks = []
 
         self.debug("commit action group %s nested %s",
-                   stack.action_group_name, nested)
-        self.emit("commit", stack, nested)
+                   stack.action_group_name, len(self.stacks))
+        self.emit("commit", stack)
 
     def undo(self):
         if self.stacks or not self.undo_stacks:
@@ -300,8 +296,8 @@ class UndoableActionLog(GObject.Object, Loggable):
 
         return stack
 
-    def _stackIsNested(self, unused_stack):
-        return bool(len(self.stacks))
+    def is_in_transaction(self):
+        return bool(self.stacks)
 
 
 class PropertyChangeTracker(GObject.Object):
diff --git a/tests/test_undo.py b/tests/test_undo.py
index 8b40234..c5d6061 100644
--- a/tests/test_undo.py
+++ b/tests/test_undo.py
@@ -225,16 +225,16 @@ class TestUndoableActionLog(TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack, nested) = self.signals[0]
+        name, (stack,) = self.signals[0]
         self.assertEqual(name, "begin")
-        self.assertFalse(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.assertEqual(self.log.undo_stacks, [])
         self.log.commit()
         self.assertEqual(len(self.signals), 2)
-        name, (stack, nested) = self.signals[1]
+        name, (stack,) = self.signals[1]
         self.assertEqual(name, "commit")
-        self.assertFalse(nested)
+        self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
@@ -246,33 +246,33 @@ class TestUndoableActionLog(TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack, nested) = self.signals[0]
+        name, (stack,) = self.signals[0]
         self.assertEqual(name, "begin")
-        self.assertFalse(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("nested")
         self.assertEqual(len(self.signals), 2)
-        name, (stack, nested) = self.signals[1]
+        name, (stack,) = self.signals[1]
         self.assertEqual(name, "begin")
-        self.assertTrue(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.assertEqual(self.log.undo_stacks, [])
         self.log.commit()
         self.assertEqual(len(self.signals), 3)
-        name, (stack, nested) = self.signals[2]
+        name, (stack,) = self.signals[2]
         self.assertEqual(name, "commit")
-        self.assertTrue(nested)
+        self.assertTrue(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
         self.assertEqual(self.log.undo_stacks, [])
         self.log.commit()
         self.assertEqual(len(self.signals), 4)
-        name, (stack, nested) = self.signals[3]
+        name, (stack,) = self.signals[3]
         self.assertEqual(name, "commit")
-        self.assertFalse(nested)
+        self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
@@ -284,15 +284,15 @@ class TestUndoableActionLog(TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack, nested) = self.signals[0]
+        name, (stack,) = self.signals[0]
         self.assertEqual(name, "begin")
-        self.assertFalse(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 2)
-        name, (stack, nested) = self.signals[1]
+        name, (stack,) = self.signals[1]
         self.assertEqual(name, "rollback")
-        self.assertFalse(nested)
+        self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
@@ -304,31 +304,31 @@ class TestUndoableActionLog(TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack, nested) = self.signals[0]
+        name, (stack,) = self.signals[0]
         self.assertEqual(name, "begin")
-        self.assertFalse(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.begin("nested")
         self.assertEqual(len(self.signals), 2)
-        name, (stack, nested) = self.signals[1]
+        name, (stack,) = self.signals[1]
         self.assertEqual(name, "begin")
-        self.assertTrue(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 3)
-        name, (stack, nested) = self.signals[2]
+        name, (stack,) = self.signals[2]
         self.assertEqual(name, "rollback")
-        self.assertTrue(nested)
+        self.assertTrue(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
         self.log.rollback()
         self.assertEqual(len(self.signals), 4)
-        name, (stack, nested) = self.signals[3]
+        name, (stack,) = self.signals[3]
         self.assertEqual(name, "rollback")
-        self.assertFalse(nested)
+        self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 0)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
@@ -339,9 +339,9 @@ class TestUndoableActionLog(TestCase):
         # begin
         self.log.begin("meh")
         self.assertEqual(len(self.signals), 1)
-        name, (stack, nested) = self.signals[0]
+        name, (stack,) = self.signals[0]
         self.assertEqual(name, "begin")
-        self.assertFalse(nested)
+        self.assertTrue(self.log.is_in_transaction())
 
         # push two actions
         action1 = DummyUndoableAction()
@@ -363,9 +363,9 @@ class TestUndoableActionLog(TestCase):
         self.assertEqual(len(self.log.redo_stacks), 0)
         self.log.commit()
         self.assertEqual(len(self.signals), 4)
-        name, (stack, nested) = self.signals[3]
+        name, (stack,) = self.signals[3]
         self.assertEqual(name, "commit")
-        self.assertFalse(nested)
+        self.assertFalse(self.log.is_in_transaction())
         self.assertEqual(len(self.log.undo_stacks), 1)
         self.assertEqual(len(self.log.redo_stacks), 0)
 
diff --git a/tests/test_undo_timeline.py b/tests/test_undo_timeline.py
index 832773d..7f0d971 100644
--- a/tests/test_undo_timeline.py
+++ b/tests/test_undo_timeline.py
@@ -121,7 +121,7 @@ class TestTimelineUndo(TestCase):
                 yield clip
 
     @staticmethod
-    def commitCb(action_log, stack, nested, stacks):
+    def commitCb(action_log, stack, stacks):
         stacks.append(stack)
 
     def testAddClip(self):
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]