Bugfix on group activation (in EmClasses all fields were always actives)

em_test.py

     display_name = {
         'eng': 'name',
         'fre': 'nom'},
-    data_handler = 'varchar')
+    data_handler = 'varchar',
+    group = index_group)
 
 index_value = index_abstract.new_field(
     'value',
     display_name = {
         'eng': 'value',
         'fre': 'valeur'},
-    data_handler = 'varchar')
+    data_handler = 'varchar',
+    group = index_group)
 
 text.new_field( 'indexes',
     display_name = {
     back_reference = ('Indexabs', 'texts'),
     allowed_classes = [index_abstract],
     default = None,
-    nullable = True)
+    nullable = True,
+    group = index_group)
 
 index_abstract.new_field( 'texts',
     display_name = {
         'fre': 'Texte contenant cette index'},
     data_handler = 'list',
     back_reference = ('Text', 'indexes'),
-    allowed_classes = [text])
+    allowed_classes = [text],
+    group = index_group)
 
 index_theme = em.new_class(
     'indexTheme',
     'theme',
     display_name = {
         'eng': 'theme'},
-    data_handler = 'varchar')
+    data_handler = 'varchar',
+    group = index_group)
 
 #em.save('xmlfile', filename = 'examples/em_test.xml')
 pickle_file = 'examples/em_test.pickle'

lodel/editorial_model/components.py

             return list(fields.values()) if uid is None else fields[uid]
         except KeyError:
             raise EditorialModelError("No such EmField '%s'" % uid)
+    
+    ##@brief Keep in __fields only fields contained in active groups
+    def _set_active_fields(self, active_groups):
+        active_fields = []
+        for grp_name, agrp in active_groups.items():
+            active_fields += [ emc for emc in agrp.components()
+                if isinstance(emc, EmField)]
+        self.__fields = { fname:fdh for fname, fdh in self.__fields.items()
+            if fdh in active_fields }
 
     ##@brief Add a field to the EmClass
     # @param emfield EmField : an EmField instance
     # @throw EditorialModelException if an EmField with same uid allready in this EmClass (overwritting allowed from parents)
     # @todo End the override checks (needs methods in data_handlers)
     def add_field(self, emfield):
+        assert_edit()
         if emfield.uid in self.__fields:
             raise EditorialModelError("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
         # Incomplete field override check
     # @param uid str : the EmField uniq id
     # @param **field_kwargs :  EmField constructor parameters ( see @ref EmField.__init__() ) 
     def new_field(self, uid, data_handler, **field_kwargs):
+        assert_edit()
         return self.add_field(EmField(uid, data_handler, **field_kwargs))
 
     def d_hash(self):
     ##@brief Add components in a group
     # @param components list : EmComponent instances list
     def add_components(self, components):
+        assert_edit()
         for component in components:
             if isinstance(component, EmField):
                 if component._emclass is None:
     ##@brief Add a dependencie
     # @param em_group EmGroup|iterable : an EmGroup instance or list of instance
     def add_dependencie(self, grp):
+        assert_edit()
         try:
             for group in grp:
                 self.add_dependencie(group)
     # @param em_group EmGroup|iterable : an EmGroup instance or list of instance
     # Useless ???
     def add_applicant(self, grp):
+        assert_edit()
         try:
             for group in grp:
                 self.add_applicant(group)

lodel/editorial_model/exceptions.py

 class EditorialModelError(Exception):
     pass
 
+
+def assert_edit():
+    from lodel import Settings
+    if not Settings.editorialmodel.editormode:
+        raise EditorialModelError("EM is readonly : editormode is OFF")
+

lodel/editorial_model/model.py

                 raise RuntimeError("No groups activated, abording...")
             if len(self.__active_classes) == 0:
                 raise RuntimeError("No active class found. Abording")
+            for clsname, acls in self.__active_classes.items():
+                acls._set_active_fields(self.__active_groups)
     
     ##@brief EmField getter
     # @param uid str : An EmField uid represented by "CLASSUID.FIELDUID"
     # @param emclass EmClass : the EmClass instance to add
     # @return emclass
     def add_class(self, emclass):
-        self.raise_if_ro()
+        assert_edit()()
         if not isinstance(emclass, EmClass):
             raise ValueError("<class EmClass> expected but got %s " % type(emclass))
         if emclass.uid in self.classes():
     # @param emgroup EmGroup : the EmGroup instance to add
     # @return emgroup
     def add_group(self, emgroup):
-        self.raise_if_ro()
+        assert_edit()()
         if not isinstance(emgroup, EmGroup):
             raise ValueError("<class EmGroup> expected but got %s" % type(emgroup))
         if emgroup.uid in self.groups():
     #@param **kwargs : EmClass constructor options ( 
     # see @ref lodel.editorial_model.component.EmClass.__init__() )
     def new_class(self, uid, **kwargs):
-        self.raise_if_ro()
+        assert_edit()()
         return self.add_class(EmClass(uid, **kwargs))
     
     ##@brief Add a new EmGroup to the editorial model
     #@param *kwargs : EmGroup constructor keywords arguments (
     # see @ref lodel.editorial_model.component.EmGroup.__init__() )
     def new_group(self, uid, **kwargs):
-        self.raise_if_ro()
+        assert_edit()()
         return self.add_group(EmGroup(uid, **kwargs))
 
     ##@brief Save a model
     # @param translator module : The translator module to use
     # @param **translator_args
     def save(self, translator, **translator_kwargs):
-        self.raise_if_ro()
+        assert_edit()()
         if isinstance(translator, str):
             translator = self.translator_from_name(translator)
         return translator.save(self, **translator_kwargs)