Merge branch 'pr-289'

Author: aleneum

tests/test_core.py

@@ -20,6 +20,14 @@
     from mock import MagicMock
 
 
+def on_exit_A(event):
+    event.model.exit_A_called = True
+
+
+def on_exit_B(event):
+    event.model.exit_B_called = True
+
+
 class TestTransitions(TestCase):
 
     def setUp(self):
@@ -266,7 +274,7 @@ def __init__(self, *args, **kwargs):
         n.advance()
         self.assertTrue(n.is_B())
         with self.assertRaises(ValueError):
-            m = NewMachine(state=['A', 'B'])
+            NewMachine(state=['A', 'B'])
 
     def test_send_event_data_callbacks(self):
         states = ['A', 'B', 'C', 'D', 'E']
@@ -463,6 +471,39 @@ def on_exit_B(self):
         self.assertEqual(len(state_b.on_enter), 1)
         self.assertEqual(len(state_b.on_exit), 1)
 
+    def test_state_callable_callbacks(self):
+
+        class Model:
+
+            def __init__(self):
+                self.exit_A_called = False
+                self.exit_B_called = False
+
+            def on_enter_A(self, event):
+                pass
+
+            def on_enter_B(self, event):
+                pass
+
+        states = [State(name='A', on_enter='on_enter_A', on_exit='tests.test_core.on_exit_A'),
+                  State(name='B', on_enter='on_enter_B', on_exit=on_exit_B),
+                  State(name='C', on_enter='tests.test_core.AAAA')]
+
+        model = Model()
+        machine = Machine(model, states=states, send_event=True, initial='A')
+        state_a = machine.get_state('A')
+        state_b = machine.get_state('B')
+        self.assertEqual(len(state_a.on_enter), 1)
+        self.assertEqual(len(state_a.on_exit), 1)
+        self.assertEqual(len(state_b.on_enter), 1)
+        self.assertEqual(len(state_b.on_exit), 1)
+        model.to_B()
+        self.assertTrue(model.exit_A_called)
+        model.to_A()
+        self.assertTrue(model.exit_B_called)
+        with self.assertRaises(AttributeError):
+            model.to_C()
+
     def test_pickle(self):
         import sys
         if sys.version_info < (3, 4):

tests/test_nesting.py

@@ -29,6 +29,10 @@
 state_separator = State.separator
 
 
+class Dummy(object):
+    pass
+
+
 class TestTransitions(TestsCore):
 
     def setUp(self):
@@ -41,6 +45,10 @@ def tearDown(self):
         State.separator = state_separator
         pass
 
+    def test_add_model(self):
+        model = Dummy()
+        self.stuff.machine.add_model(model, initial='E')
+
     def test_function_wrapper(self):
         from transitions.extensions.nesting import FunctionWrapper
         mo = MagicMock

transitions/core.py

@@ -12,6 +12,7 @@
 except ImportError:
     # python2
     pass
+
 import inspect
 import itertools
 import logging
@@ -175,8 +176,7 @@ def check(self, event_data):
                 model attached to the current machine which is used to invoke
                 the condition.
         """
-        predicate = getattr(event_data.model, self.func) if isinstance(self.func, string_types) else self.func
-
+        predicate = event_data.machine.resolve_callable(self.func, event_data)
         if event_data.machine.send_event:
             return predicate(event_data) == self.target
         return predicate(*event_data.args, **event_data.kwargs) == self.target
@@ -989,19 +989,45 @@ def callback(self, func, event_data):
             the callable will be resolved from the passed model in event_data. This function is not intended to
             be called directly but through state and transition callback definitions.
         Args:
-            func (callable or str): The callback function.
+            func (string, callable): The callback function.
+                1. First, if the func is callable, just call it
+                2. Second, we try to import string assuming it is a path to a func
+                3. Fallback to a model attribute
             event_data (EventData): An EventData instance to pass to the
                 callback (if event sending is enabled) or to extract arguments
                 from (if event sending is disabled).
         """
-        if isinstance(func, string_types):
-            func = getattr(event_data.model, func)
 
+        func = self.resolve_callable(func, event_data)
         if self.send_event:
             func(event_data)
         else:
             func(*event_data.args, **event_data.kwargs)
 
+    @staticmethod
+    def resolve_callable(func, event_data):
+        """ Converts path to a callable into callable
+        Args:
+            func (string, callable): Path to a callable
+            event_data (EventData): Currently processed event
+        Returns:
+            callable function resolved from string or func
+        """
+        if isinstance(func, string_types):
+            try:
+                func = getattr(event_data.model, func)
+            except AttributeError:
+                try:
+                    mod, name = func.rsplit('.', 1)
+                    m = __import__(mod)
+                    for n in mod.split('.')[1:]:
+                        m = getattr(m, n)
+                    func = getattr(m, name)
+                except (ImportError, AttributeError, ValueError):
+                    raise AttributeError("Callable with name '%s' could neither be retrieved from the passed "
+                                         "model nor imported from a module.")
+        return func
+
     def _has_state(self, state):
         if isinstance(state, State):
             if state in self.states.values():