Get rid of ActionFinder (in favor of NodeTreeRoot methods)

Author: idle-code

.idea/fileColors.xml

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

contextshell/Action.py

@@ -6,12 +6,14 @@
 
 
 class CallableAction(Action):
-    def __init__(self, implementation: Callable):
+    def __init__(self, implementation: Callable, name: NodePath):
+        super().__init__(name)
         self.implementation = implementation
 
-    def __call__(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
+    def invoke(self, target: NodePath, action: NodePath, arguments: Dict[Union[NodePath, int], Any]):
+        #print("Invoked with:", *args)
         args, kwargs = CallableAction.unpack_argument_tree(arguments)
-        return self.implementation(target, action, *args, **kwargs)
+        return self.implementation(target, *args, **kwargs)
 
     @staticmethod
     def unpack_argument_tree(arguments: Dict[Union[NodePath, int], Any]) -> Tuple[List[Any], Dict[NodePath, Any]]:
@@ -23,3 +25,11 @@ def unpack_argument_tree(arguments: Dict[Union[NodePath, int], Any]) -> Tuple[Li
             else:
                 kwargs[key] = value
         return args, kwargs
+
+
+def action_from_function(method_to_wrap: Callable) -> Action:
+    action_name: str = method_to_wrap.__name__
+    if action_name.endswith('_action'):
+        action_name = action_name[:-len('_action')]
+    action_name = action_name.replace('_', '.')
+    return CallableAction(method_to_wrap, NodePath(action_name))

contextshell/ActionFinder.py

@@ -16,7 +16,7 @@ def execute(self, command: Command):
         target_path = NodePath.cast(target_path)
         action_path = NodePath.cast(self._evaluate(command.name))
         arguments = map(self._evaluate, command.arguments)
-
+        # TODO: parse arguments into OrderedDict[Union[int, NodePath], Any] as in Action.invoke interface
         return self.tree.execute(target_path, action_path, *arguments)
 
     def _evaluate(self, part):

contextshell/CallableAction.py

@@ -2,68 +2,59 @@
 from contextshell.NodePath import NodePath
 from contextshell.TreeRoot import TreeRoot
 from contextshell.Action import Action
-from typing import Callable, List, Optional
+from contextshell.CallableAction import action_from_function
+from typing import Callable, List, Optional, Dict, Union, Any
 
 
 # CHECK: how to implement TemporaryTreeRoot (based on NodeTreeRoot)
 class NodeTreeRoot(TreeRoot):
     """Frontend to the (passive) node-based data storage"""
     def __init__(self):
         self.root = self.create_node(None)
-        from contextshell.ActionFinder import ActionFinder
-        self.action_finder = ActionFinder(self)
         self.install_default_actions()
 
-    def install_default_actions(self):
-        def create(tree: NodeTreeRoot, target: NodePath, action: NodePath, name, value=None):
-            tree.create(NodePath.join(target, name), value)
-
-        self.action_finder.install_action(".", "create", create)
-
-        def exists(tree: NodeTreeRoot, target: NodePath, action: NodePath, name):
-            return tree.exists(NodePath.join(target, name))
-
-        self.action_finder.install_action(".", "exists", exists)
-
-        def get(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            return tree.get(target)
+    def create_action(self, target: NodePath, path: str, value=None):
+        self.create(NodePath.join(target, path), value)
 
-        self.action_finder.install_action(".", "get", get)
+    def exists_action(self, target: NodePath, path: str) -> bool:
+        return self.exists(NodePath.join(target, path))
 
-        def set_action(tree: NodeTreeRoot, target: NodePath, action: NodePath, new_value):
-            return tree.set(target, new_value)
+    def get_action(self, target: NodePath):
+        return self.get(target)
 
-        self.action_finder.install_action(".", "set", set_action)
+    def set_action(self, target: NodePath, new_value):
+        return self.set(target, new_value)
 
-        def list_action(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            all_list = tree.list(target)
-            return list(filter(lambda p: not self.is_attribute(p), all_list))
+    def list_action(self, target: NodePath):
+        all_list = self.list(target)
+        return list(filter(lambda p: not self.is_attribute(p), all_list))
 
-        self.action_finder.install_action(".", "list", list_action)
+    def list_all_action(self, target: NodePath):
+        return self.list(target)
 
-        def list_all(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            return tree.list(target)
+    def list_attributes_action(self, target: NodePath):
+        all_list = self.list(target)
+        return list(filter(self.is_attribute, all_list))
 
-        self.action_finder.install_action(".", "list.all", list_all)
+    def list_actions_action(self, target: NodePath):
+        # FIXME: use the same mechanism as in self.find_action
+        actions_branch = NodePath.join(target, '@actions')
+        return self.list(actions_branch)
 
-        def list_attributes(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            all_list = tree.list(target)
-            return list(filter(self.is_attribute, all_list))
+    def remove_action(self, target: NodePath):
+        # CHECK: use 'path' argument?
+        return self.remove(target)
 
-        self.action_finder.install_action(".", "list.attributes", list_attributes)
-
-        def list_actions(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            # FIXME: use self.action_finder or other way of listing available actions
-            from contextshell.ActionFinder import ActionFinder
-            actions_branch = NodePath.join(target, ActionFinder.actions_branch_name)
-            return tree.list(actions_branch)
-
-        self.action_finder.install_action(".", "list.actions", list_actions)
-
-        def remove(tree: NodeTreeRoot, target: NodePath, action: NodePath):
-            return tree.remove(target)
-
-        self.action_finder.install_action(".", "remove", remove)
+    def install_default_actions(self):
+        self.install_global_action(action_from_function(self.create_action))
+        self.install_global_action(action_from_function(self.exists_action))
+        self.install_global_action(action_from_function(self.get_action))
+        self.install_global_action(action_from_function(self.set_action))
+        self.install_global_action(action_from_function(self.list_action))
+        self.install_global_action(action_from_function(self.list_all_action))
+        self.install_global_action(action_from_function(self.list_attributes_action))
+        self.install_global_action(action_from_function(self.list_actions_action))
+        self.install_global_action(action_from_function(self.remove_action))
 
     def install_global_action(self, action: Action):
         self.install_action(NodePath('.'), action)
@@ -93,7 +84,7 @@ def _find_action_in(self, target: NodePath, action: NodePath) -> Optional[Action
         return action_implementation
 
     def _is_action_implementation(self, node_value) -> bool:
-        return isinstance(node_value, Callable)
+        return isinstance(node_value, Action)
 
     # def install_type(self, type: NodeType):
     #     raise NotImplementedError()
@@ -115,10 +106,13 @@ def is_action(self, path: NodePath):
         return self._is_action_implementation(node_value)
 
     def execute(self, target: NodePath, action: NodePath, *args):
-        action_impl = self.action_finder.find_action(target, action)
+        #print("Execute: {}: {} {}".format(target, action, args))
+        action_impl = self.find_action(target, action)
         if action_impl is None:
             raise NameError("Could not find action named '{}'".format(action))
-        return action_impl(self, target, action, *args)
+        from collections import OrderedDict  # FIXME: Temporary, until execute interface changes
+        arguments = OrderedDict(enumerate(args))
+        return action_impl.invoke(target, action, arguments)
 
     def create_node(self, value):
         return Node(value)

contextshell/CommandInterpreter.py

@@ -4,5 +4,5 @@
 
 class TreeRoot(ABC):
     @abstractmethod
-    def execute(self, target: NodePath, action: NodePath, *args):
+    def execute(self, target: NodePath, action: NodePath, *args):  #FIXME: use Dict[Union[NodePath, int], Any] as arguments
         raise NotImplementedError()

contextshell/NodeTreeRoot.py

@@ -1,65 +1,68 @@
 from contextshell.NodePath import NodePath
 from contextshell.TreeRoot import TreeRoot
+from contextshell.NodeTreeRoot import NodeTreeRoot
 from tests.functional.TestExecutor import script_test
 from tests.functional.ShellTestsBase import NodeTreeTestsBase
 import unittest
 
 
 class ActionResolvingTests(NodeTreeTestsBase):
-    def install_custom_actions(self, finder):
-        def parent_action(tree: TreeRoot, target: NodePath, action: NodePath):
+    def install_custom_actions(self, tree: NodeTreeRoot):
+        from contextshell.CallableAction import action_from_function
+
+        def parent(target: NodePath):
             return "PARENT"
 
-        finder.install_action(".", "parent_action", parent_action)
+        tree.install_global_action(action_from_function(parent))
 
-        def child_action(tree: TreeRoot, target: NodePath, action: NodePath):
+        def child(target: NodePath):
             return "CHILD"
 
-        finder.install_action(".child", "child_action", child_action)
+        tree.install_action(NodePath(".child"), action_from_function(child))
 
-        def partial_action(tree: TreeRoot, target: NodePath, action: NodePath):
+        def multi_part(target: NodePath):
             pass
 
-        finder.install_action(".", "partial.action", partial_action)
+        tree.install_global_action(action_from_function(multi_part))
 
     @script_test
     def test_unknown_action(self):
         """
-        $ .: unknown_action
-        NameError: Could not find action named 'unknown_action'
+        $ .: unknown
+        NameError: Could not find action named 'unknown'
         """
 
     @script_test
     def test_parent_action_from_child(self):
         """
-        $ .child: parent_action
+        $ .child: parent
         PARENT
         """
 
     @script_test
     def test_child_action_from_child(self):
         """
-        $ .child: child_action
+        $ .child: child
         CHILD
         """
 
     @script_test
     def test_parent_action_from_parent(self):
         """
-        $ .: parent_action
+        $ .: parent
         PARENT
         """
 
     @script_test
     def test_child_action_from_parent(self):
         """
-        $ .: child_action
-        NameError: Could not find action named 'child_action'
+        $ .: child
+        NameError: Could not find action named 'child'
         """
 
     @script_test
     def test_non_action_invoke(self):
         """
-        $ .: partial
-        NameError: Could not find action named 'partial'
+        $ .: multi
+        NameError: Could not find action named 'multi'
         """

contextshell/TreeRoot.py

@@ -6,11 +6,12 @@
 
 
 class ParserTypesTests(NodeTreeTestsBase):
-    def install_custom_actions(self, finder):
-        def type_of(tree: NodeTreeRoot, target: NodePath, action: NodePath, value):
-            return type(value).__name__
+    def install_custom_actions(self, tree: NodeTreeRoot):
+        def type_of(target: NodePath, value_to_check):
+            return type(value_to_check).__name__
 
-        finder.install_action(".", "type.of", type_of)
+        from contextshell.CallableAction import action_from_function
+        tree.install_global_action(action_from_function(type_of))
 
     @script_test
     def test_int(self):

tests/functional/ActionResolvingTests.py

@@ -5,7 +5,6 @@
 from contextshell.CommandInterpreter import CommandInterpreter
 from contextshell.VirtualTree import VirtualTree
 from contextshell.NodeTreeRoot import NodeTreeRoot
-from contextshell.ActionFinder import ActionFinder
 
 
 class VirtualTreeTestsBase(unittest.TestCase, ABC):
@@ -25,8 +24,8 @@ def register_roots(self, virtual_tree: VirtualTree):
 class NodeTreeTestsBase(VirtualTreeTestsBase):
     def register_roots(self, virtual_tree: VirtualTree):
         tree_root = NodeTreeRoot()
-        self.install_custom_actions(tree_root.action_finder)
+        self.install_custom_actions(tree_root)
         virtual_tree.mount(NodePath("."), tree_root)
 
-    def install_custom_actions(self, action_finder: ActionFinder):
+    def install_custom_actions(self, tree: NodeTreeRoot):
         pass