EmGroup implementation + fixes + tests

lodel/editorial_model/component.py → lodel/editorial_model/components.py

@@ -1,6 +1,8 @@
 #-*- coding: utf-8 -*-
 
 import itertools
+import warnings
+import copy
 
 from lodel.utils.mlstring import MlString
 
@@ -47,6 +49,8 @@ class EmClass(EmComponent):
             for parent in parents:
                 if not isinstance(parent, EmClass):
                     raise ValueError("<class EmClass> expected in parents list, but %s found" % type(parent))
+        else:
+            parents = list()
         self.parents = parents
         ## @brief Stores EmFields instances indexed by field uid
         self.__fields = dict() 
@@ -63,11 +67,11 @@ class EmClass(EmComponent):
     ## @brief EmField getter
     # @param uid None | str : If None returns an iterator on EmField instances else return an EmField instance
     # @param no_parents bool : If True returns only fields defined is this class and not the one defined in parents classes
-    # @return An iterator on EmFields instances (if uid is None) else return an EmField instance
+    # @return A list on EmFields instances (if uid is None) else return an EmField instance
     def fields(self, uid = None, no_parents = False):
         fields = self.__fields if no_parents else self.__all_fields
         try:
-            return iter(fields.values()) if uid is None else fields[uid]
+            return list(fields.values()) if uid is None else fields[uid]
         except KeyError:
             raise EditorialModelError("No such EmField '%s'" % uid)
 
@@ -79,12 +83,13 @@ class EmClass(EmComponent):
         if emfield.uid in self.__fields:
             raise EditorialModelException("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
         self.__fields[emfield.uid] = emfield
+        emfield._emclass = self
     
     ## @brief Create a new EmField and add it to the EmClass
     # @param uid str : the EmField uniq id
     # @param **field_kwargs :  EmField constructor parameters ( see @ref EmField.__init__() ) 
     def new_field(self, uid, **field_kwargs):
-        return self.add_field(EmField(uid, **kwargs))
+        return self.add_field(EmField(uid, **field_kwargs))
 
 
 ## @brief Handles editorial model classes fields
@@ -100,6 +105,88 @@ class EmField(EmComponent):
     def __init__(self, uid, data_handler, display_name = None, help_text = None, group = None, **handler_kwargs):
         super().__init__(uid, display_name, help_text, group)
         self.data_handler = data_handler
-        self.data_handler_options = data_handler_options
+        self.data_handler_options = handler_kwargs
+        ## @brief Stores the emclass that contains this field (set by EmClass.add_field() method)
+        self._emclass = None
 
+
+## @brief Handles functionnal group of EmComponents
+class EmGroup(object):
+        
+    ## @brief Create a new EmGroup
+    # @note you should NEVER call the constructor yourself. Use Model.add_group instead
+    # @param uid str : Uniq identifier
+    # @param depends list : A list of EmGroup dependencies
+    # @param display_name MlString|str : 
+    # @param help_text MlString|str : 
+    def __init__(self, uid, depends = None, display_name = None, help_text = None):
+        self.uid = uid
+        ## @brief Stores the list of groups that depends on this EmGroup indexed by uid
+        self.required_by = dict()
+        ## @brief Stores the list of dependencies (EmGroup) indexed by uid
+        self.require = dict()
+        ## @brief Stores the list of EmComponent instances contained in this group
+        self.__components = set()
+
+        self.display_name = None if display_name is None else MlString(display_name)
+        self.help_text = None if help_text is None else MlString(help_text)
+        if depends is not None:
+            for grp in depends:
+                if not isinstance(grp, EmGroup):
+                    raise ValueError("EmGroup expected in depends argument but %s found" % grp)
+                self.add_dependencie(grp)
+    
+    ## @brief Returns EmGroup dependencie
+    # @param recursive bool : if True return all dependencies and their dependencies
+    # @return a dict of EmGroup identified by uid
+    def dependencies(self, recursive = False):
+        res = copy.copy(self.require)
+        if not recursive:
+            return res
+        to_scan = list(res.values())
+        while len(to_scan) > 0:
+            cur_dep = to_scan.pop()
+            for new_dep in cur_dep.require.values():
+                if new_dep not in res:
+                    to_scan.append(new_dep)
+                    res[new_dep.uid] = new_dep
+        return res
+
+    ## @brief Add components in a group
+    # @param components list : EmComponent instance list
+    def add_components(self, components):
+        for component in components:
+            if isinstance(component, EmField):
+                if component._emclass is None:
+                    warnings.warn("Adding an orphan EmField to an EmGroup")
+            elif not isinstance(component, EmClass):
+                raise EditorialModelError("Expecting components to be a list of EmComponent, but %s found in the list" % type(component))
+        self.__components |= set(components)
+
+    ## @brief Add a dependencie
+    # @param em_group EmGroup|iterable : an EmGroup instance or list of instance
+    def add_dependencie(self, grp):
+        try:
+            for group in grp:
+                self.add_dependencie(group)
+            return
+        except TypeError: pass
+                
+        if grp.uid in self.require:
+            return
+        if self.__circular_dependencie(grp):
+            raise EditorialModelError("Circular dependencie detected, cannot add dependencie")
+        self.require[grp.uid] = grp
+        grp.required_by[self.uid] = self
+    
+    ## @brief Search for circular dependencie
+    # @return True if circular dep found else False
+    def __circular_dependencie(self, new_dep):
+        return self.uid in new_dep.dependencies(True)
+
+    def __str__(self):
+        return "<class EmGroup '%s'>" % self.uid
     
+    ## @todo better implementation
+    def __repr__(self):
+        return self.__str__()

lodel/editorial_model/model.py

@@ -2,7 +2,7 @@
 from lodel.utils.mlstring import MlString
 
 from lodel.editorial_model.exceptions import *
-from lodel.editorial_model.component import EmClass, EmField
+from lodel.editorial_model.components import EmClass, EmField
 
 ## @brief Describe an editorial model
 class EditorialModel(object):

tests/test_model.py

@@ -2,8 +2,9 @@
 
 import unittest
 
-from lodel.editorial_model.component import EmComponent, EmClass, EmField
+from lodel.editorial_model.components import EmComponent, EmClass, EmField, EmGroup
 from lodel.utils.mlstring import MlString
+from lodel.editorial_model.exceptions import *
 
 class EmComponentTestCase(unittest.TestCase):
     
@@ -18,3 +19,104 @@ class EmClassTestCase(unittest.TestCase):
         self.assertEqual(cls.uid, 'testClass')
         self.assertEqual(cls.display_name, MlString('test class'))
         self.assertEqual(cls.help_text, MlString('A test class'))
+
+    def test_fields(self):
+        """ Bad test on add field method (only check uid presence) """
+        cls = EmClass('testClass', 'test_class', 'A test class')
+        cls.new_field('name', data_handler = None)
+        cls.new_field('string', data_handler = None)
+        cls.new_field('lodel_id', data_handler = None)
+
+        fields = cls.fields()
+        self.assertEqual(len(fields), 3)
+        self.assertEqual(
+            set([f.uid for f in fields]),
+            set(['name', 'string', 'lodel_id'])
+        )
+
+class EmGroupTestCase(unittest.TestCase):
+    
+    def test_init(self):
+        """ Test EmGroup instanciation """
+        grp = EmGroup('testgrp', display_name = "Test group", help_text="No Help")
+        self.assertEqual(grp.uid, 'testgrp')
+        self.assertEqual(grp.dependencies(), dict())
+        self.assertEqual(grp.display_name, MlString("Test group"))
+        self.assertEqual(grp.help_text, MlString("No Help"))
+        
+        grp2 = EmGroup('test')
+        self.assertEqual(grp2.uid, 'test')
+        self.assertEqual(grp2.display_name, None)
+        self.assertEqual(grp2.help_text, None)
+
+        grp3 = EmGroup('depends', depends = (grp, grp2))
+        self.assertEqual(set(grp3.dependencies().values()), set((grp, grp2)))
+
+    def test_deps(self):
+        """ Test dependencies """
+        grp1 = EmGroup('grp1')
+        grp2 = EmGroup('grp2')
+        grp3 = EmGroup('grp3')
+        grp4 = EmGroup('grp4')
+
+        grp2.add_dependencie(grp1)
+        grp3.add_dependencie(grp2)
+        grp4.add_dependencie(grp2)
+        grp4.add_dependencie(grp1)
+
+        self.assertEqual(set(grp1.dependencies().values()), set())
+        self.assertEqual(set(grp2.dependencies().values()), set([grp1]))
+        self.assertEqual(set(grp3.dependencies().values()), set([grp2]))
+        self.assertEqual(set(grp4.dependencies().values()), set([grp2, grp1]))
+
+        self.assertEqual(set(grp3.dependencies(True).values()), set([grp2, grp1]))
+        self.assertEqual(set(grp4.dependencies(True).values()), set([grp2, grp1]))
+
+        self.assertEqual(set(grp1.required_by.values()), set([grp2, grp4]))
+        self.assertEqual(set(grp2.required_by.values()), set([grp3, grp4]))
+        self.assertEqual(set(grp3.required_by.values()), set())
+        self.assertEqual(set(grp4.required_by.values()), set())
+
+        for grp in [grp1, grp2, grp3, grp4]:
+            for uid, dep in grp.dependencies(recursive = True).items():
+                self.assertEqual(uid, dep.uid)
+            for uid, dep in grp.required_by.items():
+                self.assertEqual(uid, dep.uid)
+    def test_deps_complex(self):
+        """ More complex dependencies handling test """
+        grps = [ EmGroup('group%d' % i) for i in range(6) ]
+        grps[5].add_dependencie( (grps[1], grps[2], grps[4]) )
+        grps[4].add_dependencie( (grps[1], grps[3]) )
+        grps[3].add_dependencie( (grps[0],) )
+        grps[1].add_dependencie( (grps[2], grps[0]) )
+        self.assertEqual(
+                            set(grps[5].dependencies(True).values()),
+                            set( grps[i] for i in range(5))
+        )
+        self.assertEqual(
+                            set(grps[4].dependencies(True).values()),
+                            set( grps[i] for i in range(4))
+        )
+        grps[2].add_dependencie(grps[0])
+        self.assertEqual(
+                            set(grps[5].dependencies(True).values()),
+                            set( grps[i] for i in range(5))
+        )
+        self.assertEqual(
+                            set(grps[4].dependencies(True).values()),
+                            set( grps[i] for i in range(4))
+        )
+        # Inserting circular deps
+        with self.assertRaises(EditorialModelError):
+            grps[0].add_dependencie(grps[5])
+
+    def test_circular_dep(self):
+        """ Test circular dependencies detection """
+        grps = [ EmGroup('group%d' % i) for i in range(10) ]
+        for i in range(1,10):
+            grps[i].add_dependencie(grps[i-1])
+
+        for i in range(1,10):
+            for j in range(i+1,10):
+                with self.assertRaises(EditorialModelError):
+                    grps[i].add_dependencie(grps[j])