Ajout getter

lodel/editorial_model/components.py

@@ -228,9 +228,46 @@ class EmGroup(object):
                     to_scan.append(new_dep)
                     res[new_dep.uid] = new_dep
         return res
+    
+    ## @brief Returns EmGroup applicants
+    # @param recursive bool : if True return all dependencies and their dependencies
+    # @returns a dict of EmGroup identified by uid
+    def applicants(self, recursive = False):
+        res = copy.copy(self.required_by)
+        if not recursive:
+            return res
+        to_scan = list(res.values())
+        while len(to_scan) > 0:
+            cur_app = to_scan.pop()
+            for new_app in cur_app.required_by.values():
+                if new_app not in res:
+                    to_scan.append(new_app)
+                    res[new_app.uid] = new_app
+        return res
+    
+	## @brief Returns EmGroup components
+    # @returns a copy of the set of components
+    def components(self):
+        return (self.__components).copy()
 
+    ## @brief Returns EmGroup display_name
+    #  @param lang str | None : If None return default lang translation
+    #  @returns None if display_name is None, a str for display_name else
+    def get_display_name(self, lang=None):
+        name=self.display_name
+        if name is None : return None
+        return name.get(lang);
+
+    ## @brief Returns EmGroup help_text
+    #  @param lang str | None : If None return default lang translation
+    #  @returns None if display_name is None, a str for display_name else
+    def get_help_text(self, lang=None):
+        help=self.help_text
+        if help is None : return None
+        return help.get(lang);
+    
     ## @brief Add components in a group
-    # @param components list : EmComponent instance list
+    # @param components list : EmComponent instances list
     def add_components(self, components):
         for component in components:
             if isinstance(component, EmField):
@@ -255,11 +292,32 @@ class EmGroup(object):
             raise EditorialModelError("Circular dependencie detected, cannot add dependencie")
         self.require[grp.uid] = grp
         grp.required_by[self.uid] = self
+        
+    ## @brief Add a applicant
+    # @param em_group EmGroup|iterable : an EmGroup instance or list of instance
+    def add_applicant(self, grp):
+        try:
+            for group in grp:
+                self.add_applicant(group)
+            return
+        except TypeError: pass
+                
+        if grp.uid in self.required_by:
+            return
+        if self.__circular_applicant(grp):
+            raise EditorialModelError("Circular applicant detected, cannot add applicant")
+        self.required_by[grp.uid] = grp
+        grp.require[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)
+    
+    ## @brief Search for circular applicant
+    # @return True if circular app found else False
+    def __circular_applicant(self, new_app):
+        return self.uid in new_app.applicants(True)
 
     ## @brief Fancy string representation of an EmGroup
     # @return a string

lodel/editorial_model/model.py

@@ -24,7 +24,7 @@ class EditorialModel(object):
     
     ## @brief EmClass accessor
     # @param uid None | str : give this argument to get a specific EmClass
-    # @return if uid given return an EmClass else return an EmClass iterator
+    # @return if uid is given returns an EmClass else returns an EmClass iterator
     def classes(self, uid = None):
         try:
             return self.__elt_getter(self.__classes, uid)
@@ -33,7 +33,7 @@ class EditorialModel(object):
 
     ## @brief EmGroup getter
     # @param uid None | str : give this argument to get a specific EmGroup
-    # @return if uid given return an EmGroup else return an EmGroup iterator
+    # @return if uid is given returns an EmGroup else returns an EmGroup iterator
     def groups(self, uid = None):
         try:
             return self.__elt_getter(self.__groups, uid)

tests/editorial_model/test_model.py

@@ -159,6 +159,18 @@ class EmGroupTestCase(unittest.TestCase):
 
         grp3 = EmGroup('depends', depends = (grp, grp2))
         self.assertEqual(set(grp3.dependencies().values()), set((grp, grp2)))
+        
+    def test_add_comps(self):
+        """ Test components adding in groups"""
+        grp = EmGroup('grp')
+        cpn1 = EmField('test1','integer')
+        cpn2 = EmClass('testClass', 'test class')
+        grp.add_components([cpn1,cpn2])
+        
+        s1=grp.components()
+        s2=grp.components()
+        s1.add(EmField('test2','varchar'))
+        self.assertEqual(s2,set([cpn1,cpn2]));
 
     def test_deps(self):
         """ Test dependencies """
@@ -190,6 +202,60 @@ class EmGroupTestCase(unittest.TestCase):
                 self.assertEqual(uid, dep.uid)
             for uid, dep in grp.required_by.items():
                 self.assertEqual(uid, dep.uid)
+                
+    def test_apps(self):
+        """ Test applicants """
+        grp1 = EmGroup('grp1')
+        grp2 = EmGroup('grp2')
+        grp3 = EmGroup('grp3')
+        grp4 = EmGroup('grp4')
+
+        grp2.add_applicant(grp1)
+        grp3.add_applicant(grp2)
+        grp4.add_applicant(grp2)
+        grp4.add_applicant(grp1)
+
+        self.assertEqual(set(grp1.applicants().values()), set())
+        self.assertEqual(set(grp2.applicants().values()), set([grp1]))
+        self.assertEqual(set(grp3.applicants().values()), set([grp2]))
+        self.assertEqual(set(grp4.applicants().values()), set([grp2, grp1]))
+
+        self.assertEqual(set(grp3.applicants(True).values()), set([grp2, grp1]))
+        self.assertEqual(set(grp4.applicants(True).values()), set([grp2, grp1]))
+
+        self.assertEqual(set(grp1.required_by.values()), set())
+        self.assertEqual(set(grp2.required_by.values()), set([grp1]))
+        self.assertEqual(set(grp3.required_by.values()), set([grp2]))
+        self.assertEqual(set(grp4.required_by.values()), set([grp2,grp1]))
+
+        for grp in [grp1, grp2, grp3, grp4]:
+            for uid, dep in grp.applicants(recursive = True).items():
+                self.assertEqual(uid, dep.uid)
+            for uid, dep in grp.required_by.items():
+                self.assertEqual(uid, dep.uid)
+                
+    def test_display_name(self):
+        grp = EmGroup('grp',None,'Test affichage du nom')
+        a = grp.get_display_name()
+        b = a
+        b = 'Test de copie du nom'
+        self.assertEqual(a,'Test affichage du nom')
+        grp1 = EmGroup('grp')
+        c = grp1.get_display_name()
+        self.assertEqual(c, None)
+        with self.assertRaises(ValueError): grp.get_display_name('ita')
+        
+    def test_help_text(self):
+        grp = EmGroup('grp',None,None,'Test affichage du nom')
+        a = grp.get_help_text()
+        b = a
+        b = 'Test de copie du nom'
+        self.assertEqual(a,'Test affichage du nom')
+        grp1 = EmGroup('grp')
+        c = grp1.get_help_text()
+        self.assertEqual(c, None)
+        with self.assertRaises(ValueError): grp.get_help_text('ita')
+            
     def test_deps_complex(self):
         """ More complex dependencies handling test """
         grps = [ EmGroup('group%d' % i) for i in range(6) ]
@@ -235,3 +301,4 @@ class EmGroupTestCase(unittest.TestCase):
         e_hash = 0x74657374677270333130363537393137343730343438343139303233393838303936373730323936353536393032313839313536333632313037343435323138313735343936303237373532343436303639363137
         self.assertEqual(grp.d_hash(), e_hash)
 
+