started work on composite pattern

pypatterns/structural/composite.py

@@ -0,0 +1,63 @@
+
+
+class Composite(object):
+    """
+    Composite class as part of the Composite pattern.
+    """
+    def __init__(self, interface):
+        """
+        Initialize a new Composite instance.
+        """
+        self.components = set()
+        self.interface = interface
+        self._method_names = [method for method in dir(interface) if callable(getattr(interface, method))]
+
+    def add_component(self, component):
+        """
+        Add a component to this composite.
+
+        @param component: The component to add to this Composite
+        """
+        component_methods = [method for method in dir(component) if callable(getattr(component, method))]
+        for method_name in self._method_names:
+            if method_name in component_methods:
+                continue
+            else:
+                raise AttributeError
+        else:
+            self.components.add(component)
+
+    def remove_component(self, component):
+        """
+        Remove a component from this composite.
+
+        @param component: The component to remove from this Composite.
+        """
+        try:
+            self.components.remove(component)
+        except KeyError:
+            pass
+
+    def delegate(self, func_name):
+        """
+        Apply a function to all child components by function name.
+
+        @param func_name: The name of the function to call with all child components.
+        @type func_name: str
+        """
+        for component in self.components:
+            attribute = getattr(component, func_name)
+            if callable(attribute):
+                attribute()
+            else:
+                raise AttributeError()
+
+    def __getattr__(self, item):
+        """
+        Override getattr to delegate all function calls to children.
+
+        @param item: The function to call with this composites children components.
+        @type item: str
+        @return: A function that when called will call all child functions with the given function name.
+        """
+        return lambda: self.delegate(item)

tests/structural_tests/test_composite.py

@@ -0,0 +1,125 @@
+from abc import ABCMeta, abstractmethod
+from unittest import TestCase
+from pypatterns.structural.composite import Composite
+
+
+class CompositeTestCase(TestCase):
+    """
+    Unit testing class for the Composite class.
+    """
+    def setUp(self):
+        """
+        Initialize testing data.
+        """
+        class Component(object, metaclass=ABCMeta):
+
+            @abstractmethod
+            def do_something(self):
+                pass
+
+        class LeafOne(Component):
+
+            def __init__(self):
+                self.did_something = False
+
+            def do_something(self):
+                self.did_something = True
+
+        class LeafTwo(Component):
+
+            def __init__(self):
+                self.did_something = False
+
+            def do_something(self):
+                self.did_something = True
+
+        self.component_class = Component
+        self.leaf_one = LeafOne()
+        self.leaf_two = LeafTwo()
+
+    def test_init(self):
+
+        composite = Composite(self.component_class)
+
+        self.assertIn('do_something', composite._method_names)
+
+    def test_add_invalid_component(self):
+
+        composite = Composite(self.component_class)
+
+        class BadComponent(object):
+
+            def foo(self):
+                pass
+
+        with self.assertRaises(AttributeError):
+            composite.add_component(BadComponent)
+
+    def test_add_component(self):
+
+        composite = Composite(self.component_class)
+        composite.add_component(self.leaf_one)
+        composite.add_component(self.leaf_two)
+        try:
+            composite.add_component(self.leaf_two)
+        except:
+            raise AssertionError
+        else:
+            self.assertSetEqual({self.leaf_one, self.leaf_two}, composite.components)
+
+    def test_remove_component(self):
+
+        composite = Composite(self.component_class)
+
+        composite.add_component(self.leaf_one)
+        composite.add_component(self.leaf_two)
+
+        composite.remove_component(self.leaf_one)
+        composite.remove_component(self.leaf_two)
+        try:
+            composite.remove_component(self.leaf_two)
+        except:
+            raise AssertionError
+        else:
+            self.assertSetEqual(set(), composite.components)
+
+    def test_delegate(self):
+
+        composite = Composite(self.component_class)
+
+        composite.add_component(self.leaf_one)
+        composite.add_component(self.leaf_two)
+
+        composite.delegate('do_something')
+
+        self.assertTrue(self.leaf_one.did_something)
+        self.assertTrue(self.leaf_two.did_something)
+
+        self.leaf_one.did_something = False
+        self.leaf_two.did_something = False
+
+    def test_getattr(self):
+
+        composite = Composite(self.component_class)
+
+        composite.add_component(self.leaf_one)
+        composite.add_component(self.leaf_two)
+
+        composite.do_something()
+
+        self.assertTrue(self.leaf_one.did_something)
+        self.assertTrue(self.leaf_two.did_something)
+
+        self.leaf_one.did_something = False
+        self.leaf_two.did_something = False
+
+    def test_invalid_getattr(self):
+
+        composite = Composite(self.component_class)
+
+        composite.add_component(self.leaf_one)
+        composite.add_component(self.leaf_two)
+
+        with self.assertRaises(AttributeError):
+            composite.foo()
+            composite.did_something()