Add action installation/resolving features to NodeTreeRoot

Author: idle-code

contextshell/Action.py

@@ -4,6 +4,10 @@
 
 
 class Action(ABC):
+    def __init__(self, name: NodePath):
+        assert name.is_relative
+        self.name = name
+
     @abstractmethod
     def __call__(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
         raise NotImplementedError()

contextshell/NodeTreeRoot.py

@@ -1,10 +1,11 @@
 from contextshell.Node import Node
 from contextshell.NodePath import NodePath
 from contextshell.TreeRoot import TreeRoot
-from typing import Callable, List
+from contextshell.Action import Action
+from typing import Callable, List, Optional
 
 
-# TODO: check how implement TemporaryTreeRoot (based on NodeTreeRoot)
+# CHECK: how to implement TemporaryTreeRoot (based on NodeTreeRoot)
 class NodeTreeRoot(TreeRoot):
     """Frontend to the (passive) node-based data storage"""
     def __init__(self):
@@ -64,6 +65,39 @@ def remove(tree: NodeTreeRoot, target: NodePath, action: NodePath):
 
         self.action_finder.install_action(".", "remove", remove)
 
+    def install_global_action(self, action: Action):
+        self.install_action(NodePath('.'), action)
+
+    def install_action(self, target: NodePath, action: Action):
+        self.create(NodePath.join(target, '@actions', action.name), action)
+
+    def find_action(self, target: NodePath, action: NodePath) -> Optional[Action]:
+        possible_locations = (
+            target,
+            NodePath.join(target, '@type'),
+            NodePath('.')
+        )
+        for candidate_path in possible_locations:
+            action_implementation = self._find_action_in(candidate_path, action)
+            if action_implementation is not None:
+                return action_implementation
+        return None
+
+    def _find_action_in(self, target: NodePath, action: NodePath) -> Optional[Action]:
+        action_node = self._resolve_optional_path(NodePath.join(target, '@actions', action))
+        if action_node is None:
+            return None
+        action_implementation = action_node.get()
+        if not self._is_action_implementation(action_implementation):
+            return None
+        return action_implementation
+
+    def _is_action_implementation(self, node_value) -> bool:
+        return isinstance(node_value, Callable)
+
+    # def install_type(self, type: NodeType):
+    #     raise NotImplementedError()
+
     def is_attribute(self, path: NodePath):
         return path.startswith('@')
 
@@ -78,7 +112,7 @@ def list_actions(self, path: NodePath) -> List[NodePath]:
 
     def is_action(self, path: NodePath):
         node_value = self.get(path)
-        return isinstance(node_value, Callable)
+        return self._is_action_implementation(node_value)
 
     def execute(self, target: NodePath, action: NodePath, *args):
         action_impl = self.action_finder.find_action(target, action)

tests/unit/NodeTreeRootTests.py

@@ -1,4 +1,6 @@
 import unittest
+from typing import Dict, Union, Any
+
 from contextshell.NodePath import NodePath as np
 from contextshell.NodePath import NodePath
 from contextshell.TreeRoot import TreeRoot
@@ -280,3 +282,66 @@ def test_node_specific_actions(self):
         child_actions = tree.list_actions(child_path)
 
         self.assertSequenceEqual(['test'] + ListActions.default_actions, child_actions)
+
+
+from contextshell.Action import Action
+
+
+class FakeAction(Action):
+    def __init__(self, name: NodePath=np('action')):
+        super().__init__(name)
+
+    def __call__(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
+        pass
+
+
+class FindActionTests(unittest.TestCase):
+    def test_find_nonexistent_target(self):
+        tree = create_tree()
+        global_action = FakeAction(np('action'))
+        tree.install_global_action(global_action)
+
+        found_action = tree.find_action(np('.nonexistent'), np('action'))
+
+        self.assertIs(global_action, found_action)
+
+    def test_find_nonexistent_action(self):
+        tree = create_tree()
+
+        found_action = tree.find_action(np('.'), np('action'))
+
+        self.assertIsNone(found_action)
+
+    def test_find_invalid_action(self):
+        tree = create_tree()
+        tree.create(np('[email protected]'), 123)
+
+        found_action = tree.find_action(np('.'), np('action'))
+
+        self.assertIsNone(found_action)
+
+    def test_resolve_order_target_before_type(self):
+        tree = create_tree()
+        action_name = np('action')
+        type_action = FakeAction(action_name)
+        target_action = FakeAction(action_name)
+        tree.create(np('.target'))
+        tree.install_action(np('.target.@type'), type_action)
+        tree.install_action(np('.target'), target_action)
+
+        found_action = tree.find_action(np('.target'), action_name)
+
+        self.assertIs(target_action, found_action)
+
+    def test_resolve_order_type_before_global(self):
+        tree = create_tree()
+        tree.create(np('.target.@type'))
+        action_name = np('action')
+        global_action = FakeAction(action_name)
+        type_action = FakeAction(action_name)
+        tree.install_global_action(global_action)
+        tree.install_action(np('.target.@type'), type_action)
+
+        found_action = tree.find_action(np('.target'), action_name)
+
+        self.assertIs(type_action, found_action)