Introduction of LeFactory and its generatePython method

LeFactory.generatePython() is a method that generate LeObject code and python classes for each EmClass and EmType in an EditorialModel

EditorialModel/fields.py

@@ -47,7 +47,6 @@ class EmField(EmComponent):
         if not fieldtype_instance.check(default):
             raise TypeError("Default value ('%s') is not valid given the fieldtype '%s'"%(default, fieldtype))
 
-
         self.nullable = nullable
         self.default = default
         self.uniq = uniq
@@ -62,6 +61,12 @@ class EmField(EmComponent):
     def fieldtypes_list():
         return [f for f in EditorialModel.fieldtypes.__all__ if f != '__init__']
 
+    ## @brief Get the fieldtype instance
+    # @return a fieldtype instance
+    def fieldtype_instance(self):
+        return self._fieldtype_cls(self._fieldtype_args)
+        
+
     ## @brief Return the list of relation fields for a rel_to_type
     # @return None if the field is not a rel_to_type else return a list of EmField
     def rel_to_type_fields(self):

EditorialModel/fieldtypes/generic.py

@@ -51,13 +51,21 @@ class GenericFieldType(object):
         pass
 
     ## @brief Given a fieldtype name return the associated python class
+    # @param fieldtype_name str : A fieldtype name
     # @return An GenericFieldType derivated class
     @staticmethod
-    def from_name(name):
-        module_name = 'EditorialModel.fieldtypes.%s'%(name)
-        mod = importlib.import_module(module_name)
+    def from_name(fieldtype_name):
+        mod = importlib.import_module(GenericFieldType.module_name(fieldtype_name))
         return mod.EmFieldType
 
+    ## @brief Get a module name given a fieldtype name
+    # @param fieldtype_name str : A fieldtype name
+    # @return a string representing a python module name
+    @staticmethod
+    def module_name(fieldtype_name):
+        return 'EditorialModel.fieldtypes.%s'%(fieldtype_name)
+        
+
     
     ## @brief Transform a value into a valid python representation according to the fieldtype
     # @param value ? : The value to cast

leobject/lefactory.py

@@ -0,0 +1,85 @@
+#-*- coding: utf-8 -*-
+
+import EditorialModel
+from EditorialModel.model import Model
+from EditorialModel.fieldtypes.generic import GenericFieldType
+
+## @brief The factory that will return LeObject childs instances
+#
+# The name is not good but i've no other ideas for the moment
+class LeFactory(object):
+    
+    def __init__(self):raise NotImplementedError("Not designed (yet?) to be implemented")
+
+    ## @brief Generate python code containing the LeObject API
+    # @param model_args dict : Dict of Model __init__ method arguments
+    # @param datasource_args dict : Dict of datasource __init__ method arguments
+    # @return A string representing python code
+    @staticmethod
+    def generate_python(backend_cls, backend_args, datasource_cls, datasource_args):
+        result = ""
+        result += "#-*- coding: utf-8 -*-\n"
+        #Putting import directives in result
+        result += "\n\n\
+from EditorialModel.model import Model\n\
+from leobject.leobject import _LeObject\n\
+from leobject.leclass import LeClass\n\
+from leobject.letype import LeType\n\
+import EditorialModel.fieldtypes\n\
+"
+
+        result += "\n\
+import %s\n\
+import %s\n\
+"%(backend_cls.__module__, datasource_cls.__module__)
+
+        #Generating the code for LeObject class
+        backend_constructor = '%s.%s(**%s)'%(backend_cls.__module__, backend_cls.__name__, backend_args.__repr__())
+        result += "\n\
+class LeObject(_LeObject):\n\
+    _model = Model(backend=%s)\n\
+    _datasource = %s(**%s)\n\
+\n\
+"%(backend_constructor, datasource_cls.__name__, datasource_args.__repr__())
+
+        model = Model(backend=backend_cls(**backend_args))
+        
+        for emclass in model.components(EditorialModel.classes.EmClass):
+            cls_fields = dict()
+            fieldgroups = emclass.fieldgroups()
+            for fieldgroup in fieldgroups:
+                cls_fields[fieldgroup.name] = dict()
+                for field in fieldgroup.fields():
+                    fieldtype_constructor = '%s.EmFieldType(**%s)'%(
+                        GenericFieldType.module_name(field.fieldtype),
+                        field._fieldtype_args.__repr__(),
+                    )
+                    cls_fields[fieldgroup.name][field.name] = fieldtype_constructor
+            
+            result += "\n\
+class %s(LeObject, LeClass):\n\
+    _cls_fields = %s\n\
+\n\
+"%(emclass.name.title(), cls_fields.__repr__())
+
+        for emtype in model.components(EditorialModel.types.EmType):
+            type_fields = dict()
+            fieldgroups = emtype.fieldgroups()
+            for fieldgroup in fieldgroups:
+                type_fields[fieldgroup.name] = dict()
+                for field in fieldgroup.fields(emtype.uid):
+                    fieltype_constructor = '%s.EmFieldType(**%s)'%(
+                        GenericFieldType.module_name(field.fieldtype),
+                        field._fieldtype_args.__repr__(),
+                    )
+                    type_fields[fieldgroup.name][field.name] = fieldtype_constructor
+
+            result += "\n\
+class %s(%s,LeType):\n\
+    _fields = %s\n\
+    _leClass = %s\n\
+\n\
+"%(emtype.name.title(), emtype.em_class.name.title(), type_fields.__repr__(), emtype.em_class.name.title())
+
+        return result
+