applied changes of #473 to auto transitions as well

Author: aleneum

Changelog.md

@@ -5,6 +5,7 @@
 Release 0.8.3 is a minor release and contains several bugfixes mostly related to `HierarchicalStateMachine`:
 
 - Feature #473: Assign `is_<model_attribute>_<state_name>` instead of `is_<state_name>` when `model_attribute != "state"` to enable multiple versions of such convenience functions. A warning will be raised when `is_<state_name>` is used. (thanks @artofhuman)
+- Similarly, auto transitions (`to_<state_name>`) will be assigned as `to_<model_attribute>_<state_name>`. `to_<state_name>` will work as before but raise a warning until version 0.9.0.
 - Bugfix: `allow_substates` did not consider enum states
 - Feature: Nested enums can now be passed in a dict as `children` with `initial` parameter
 - Bugfix #449: get_triggers/get_transitions did not return nested triggers correctly (thanks @alexandretanem)

README.md

@@ -347,7 +347,7 @@ machine.get_state(lump.state).name
 >>> 'solid'
 ```
 
-If you'd like you can choose your own state attribute name by passing the `model_attribute` argument while initializing the `Machine`. This will also change the name of `is_«state name»()` to `is_«model_attribute»_«state name»()` though. This is done to allow multiple machines to work on the same model with individual state attribute names.
+If you'd like you can choose your own state attribute name by passing the `model_attribute` argument while initializing the `Machine`. This will also change the name of `is_«state name»()` to `is_«model_attribute»_«state name»()` though. Similarly, auto transitions will be named `to_«model_attribute»_«state name»()` instead of `to_«state name»()`. This is done to allow multiple machines to work on the same model with individual state attribute names.
 
 ```python
 lump = Matter()
@@ -357,6 +357,8 @@ lump.matter_state
 # with a custom 'model_attribute', states can also be checked like this:
 lump.is_matter_state_solid()
 >>> True
+lump.to_matter_state_gas()
+>>> True
 ```
 
 #### <a name="enum-state"></a>Enumerations
@@ -966,7 +968,7 @@ machine.add_model(Matter())
 machine.add_model(Matter(), initial='liquid')
 ```
 
-Models with multiple states could attach multiple machines using different `model_attribute` values. As mentioned in [Checking state](#checking-state), this will add custom `is_<model_attribute>_<state_name>` functions: 
+Models with multiple states could attach multiple machines using different `model_attribute` values. As mentioned in [Checking state](#checking-state), this will add custom `is/to_<model_attribute>_<state_name>` functions: 
 
 ```python
 lump = Matter()
@@ -983,6 +985,10 @@ lump.shipping_state
 >>> 'delivered'
 lump.is_shipping_state_delivered()  # check the custom field.
 >>> True
+lump.to_shipping_state_shipping()
+>>> True
+lump.is_shipping_state_delivered()
+>>> False
 ```
 
 ### Logging

tests/test_core.py

@@ -1097,6 +1097,8 @@ def __init__(self):
         assert instance.car_state == 'B'
         assert instance.is_driver_state_A()
         assert not instance.is_driver_state_B()
+        assert instance.to_driver_state_B()
+        assert instance.driver_state == 'B'
 
     def test_initial_not_registered(self):
         m1 = self.machine_cls(states=['A', 'B'], initial=self.machine_cls.state_cls('C'))
@@ -1125,7 +1127,12 @@ def __init__(self):
             machine_a = Machine(instance, states=['A', 'B'], initial='A', model_attribute='car_state')
             machine_b = Machine(instance, states=['A', 'B'], initial='B', model_attribute='driver_state')
             self.assertEqual(0, len(w))
-            self.assertEqual(True, instance.is_A())
-            self.assertEqual(True, instance.is_A())
+            self.assertTrue(instance.is_A())
+            self.assertTrue(instance.is_A())
             self.assertEqual(1, len(w))
             self.assertEqual(w[0].category, DeprecationWarning)
+            instance.to_B()
+            self.assertEqual('B', instance.car_state)
+            self.assertFalse(instance.is_A())
+            self.assertEqual(2, len(w))
+            self.assertEqual(w[1].category, DeprecationWarning)

transitions/core.py

@@ -784,10 +784,23 @@ def add_states(self, states, on_enter=None, on_exit=None,
                 for a_state in self.states.keys():
                     # add all states as sources to auto transitions 'to_<state>' with dest <state>
                     if a_state == state.name:
-                        self.add_transition('to_%s' % a_state, self.wildcard_all, a_state)
+                        if self.model_attribute == 'state':
+                            method_name = 'to_%s' % a_state
+                        else:
+                            method_name = 'to_%s_%s' % (self.model_attribute, a_state)
+                            self.add_transition('to_%s' % a_state, self.wildcard_all, a_state,
+                                                prepare=partial(_warning_wrapper_to, 'to_%s' % a_state))
+                        self.add_transition(method_name, self.wildcard_all, a_state)
+
                     # add auto transition with source <state> to <a_state>
                     else:
-                        self.add_transition('to_%s' % a_state, state.name, a_state)
+                        if self.model_attribute == 'state':
+                            method_name = 'to_%s' % a_state
+                        else:
+                            method_name = 'to_%s_%s' % (self.model_attribute, a_state)
+                            self.add_transition('to_%s' % a_state, state.name, a_state,
+                                                prepare=partial(_warning_wrapper_to, 'to_%s' % a_state))
+                        self.add_transition(method_name, state.name, a_state)
 
     def _add_model_to_state(self, state, model):
         # Add convenience function 'is_<state_name>' (e.g. 'is_A') to the model.
@@ -796,20 +809,11 @@ def _add_model_to_state(self, state, model):
 
         func = partial(self.is_state, state.value, model)
         if self.model_attribute == 'state':
-            meth_name = 'is_%s' % state.name
+            method_name = 'is_%s' % state.name
         else:
-            meth_name = 'is_%s_%s' % (self.model_attribute, state.name)
-
-            # TODO: Remove in 0.9.0
-            def _warning_wrapper(*args, **kwargs):
-                warnings.warn("Starting from transitions version 0.8.3, 'is_<state_name>' convenience functions will be"
-                              " assigned to 'is_<model_attribute>_<state_name>' when 'model_attribute "
-                              "!= \"state\"'. In 0.9.0, 'is_<state_name>' will NOT be assigned anymore when "
-                              "'model_attribute != \"state\"'! Please adjust your code and use "
-                              "'{0}' instead.".format(meth_name), DeprecationWarning)
-                return func(*args, **kwargs)
-            self._checked_assignment(model, 'is_%s' % state.name, _warning_wrapper)
-        self._checked_assignment(model, meth_name, func)
+            method_name = 'is_%s_%s' % (self.model_attribute, state.name)
+            self._checked_assignment(model, 'is_%s' % state.name, partial(_warning_wrapper_is, method_name, func))
+        self._checked_assignment(model, method_name, func)
 
         # Add dynamic method callbacks (enter/exit) if there are existing bound methods in the model
         # except if they are already mentioned in 'on_enter/exit' of the defined state
@@ -1215,3 +1219,21 @@ def __init__(self, value):
 
     def __str__(self):
         return repr(self.value)
+
+
+# TODO: Remove in 0.9.0
+def _warning_wrapper_is(meth_name, func, *args, **kwargs):
+    warnings.warn("Starting from transitions version 0.8.3, 'is_<state_name>' convenience functions will be"
+                  " assigned to 'is_<model_attribute>_<state_name>' when 'model_attribute "
+                  "!= \"state\"'. In 0.9.0, 'is_<state_name>' will NOT be assigned anymore when "
+                  "'model_attribute != \"state\"'! Please adjust your code and use "
+                  "'{0}' instead.".format(meth_name), DeprecationWarning)
+    return func(*args, **kwargs)
+
+
+def _warning_wrapper_to(meth_name, *args, **kwargs):
+    warnings.warn("Starting from transitions version 0.8.3, 'to_<state_name>' convenience functions will be"
+                  " assigned to 'to_<model_attribute>_<state_name>' when 'model_attribute "
+                  "!= \"state\"'. In 0.9.0, 'to_<state_name>' will NOT be assigned anymore when "
+                  "'model_attribute != \"state\"'! Please adjust your code and use "
+                  "'{0}' instead.".format(meth_name), DeprecationWarning)