Modified EmField and Model to fit with the new fieldtypes

EditorialModel/fields.py

 
 from EditorialModel.components import EmComponent
 from EditorialModel.exceptions import EmComponentCheckError
+from EditorialModel.fieldtypes.generic import GenericFieldType
 import EditorialModel
 import EditorialModel.fieldtypes
 #from django.db import models
 
     ranked_in = 'fieldgroup_id'
 
-    ftype = None
-    help = 'Default help text'
-
     ## Instanciate a new EmField
     # @todo define and test type for icon and fieldtype
     # @warning nullable == True by default
     def __init__(self, model, uid, name, fieldgroup_id, fieldtype, optional=False, internal=False, rel_field_id=None, icon='0', string=None, help_text=None, date_update=None, date_create=None, rank=None, nullable=True, default=None, uniq=False, **kwargs):
 
-        if self.ftype is None:
-            raise NotImplementedError("Trying to instanciate an EmField and not one of the fieldtypes child classes")
-
         self.fieldgroup_id = fieldgroup_id
         self.check_type('fieldgroup_id', int)
         self.optional = optional
         self.icon = icon
 
         #Field type elements
+        self._fieldtype_cls = GenericFieldType.from_name(fieldtype)
+
         self.fieldtype = fieldtype
+        self._fieldtype_args = kwargs
+        self._fieldtype_args.update({'nullable' : nullable, 'default' : default, 'uniq' : uniq})
+        self._fieldtype_instance = self._fieldtype_cls(**self._fieldtype_args)
+
+
         self.nullable = nullable
         self.default = default
         self.uniq = uniq
-
-        if len(kwargs) > 0:
-            for kwargs_f in kwargs:
-                warnings.warn("Argument '%s' not used and will be invalid for EmField __init__" % kwargs_f, SyntaxWarning)
+ 
+        for kname, kval in kwargs.items():
+            setattr(self, kname, kval)
 
         super(EmField, self).__init__(model=model, uid=uid, name=name, string=string, help_text=help_text, date_update=date_update, date_create=date_create, rank=rank)
 
-    @staticmethod
-    ## @brief Return an EmField subclass given a wanted field type
-    # @return An EmField subclass
-    # @throw When not found
-    # @see EmField::fieldtypes()
-    def get_field_class(ftype, **kwargs):
-        if ftype == 'integer':
-            ftype_module = importlib.import_module('EditorialModel.fieldtypes.int')
-        else:
-            ftype_module = importlib.import_module('EditorialModel.fieldtypes.%s' % ftype)
-
-        return ftype_module.fclass
-
     @staticmethod
     ## @brief Return the list of allowed field type
     def fieldtypes_list():
         return [f for f in EditorialModel.fieldtypes.__all__ if f != '__init__']
 
-    ## @brief Abstract method that should return a validation function
-    # @param raise_e Exception : if not valid raise this exception
-    # @param ret_valid : if valid return this value
-    # @param ret_invalid : if not valid return this value
-    def validation_function(self, raise_e=None, ret_valid=None, ret_invalid=None):
-        if self.__class__ == EmField:
-            raise NotImplementedError("Abstract method")
-        if raise_e is None and ret_valid is None:
-            raise AttributeError("Behavior doesn't allows to return a valid validation function")
-
-        return False
-
     ## @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/bool.py

 
 from EditorialModel.fieldtypes.generic import GenericFieldType
 
-class EmFieldBool(GenericFieldType):
+class EmFieldType(GenericFieldType):
 
     help = 'A basic boolean field'
 
     ## @brief A char field
     # @brief max_length int : The maximum length of this field
     def __init__(self, **kwargs):
-        super(EmFieldBool, self).__init__(ftype='bool',**kwargs)
+        super(EmFieldType, self).__init__(ftype='bool',**kwargs)
 

EditorialModel/fieldtypes/char.py

 
 from EditorialModel.fieldtypes.generic import GenericFieldType
 
-class EmFieldChar(GenericFieldType):
+class EmFieldType(GenericFieldType):
 
     help = 'Basic string (varchar) field. Take max_length=64 as option'
 
     # @brief max_length int : The maximum length of this field
     def __init__(self, max_length=64, **kwargs):
         self.max_length = max_length
-        super(EmFieldChar, self).__init__(ftype = 'char', **kwargs)
+        super(EmFieldType, self).__init__(ftype = 'char', **kwargs)
 

EditorialModel/fieldtypes/datetime.py

 #-*- coding: utf-8 -*-
 
-from EditorialModel.fields import EmField
+from EditorialModel.fieldtypes import GenericFieldType
 
 
-class EmFieldDatetime(EmField):
+class EmFieldType(GenericFieldType):
 
     help = 'A datetime field. Take two boolean options now_on_update and now_on_create'
 
     def __init__(self, now_on_update=False, now_on_create=False, **kwargs):
         self.now_on_update = now_on_update
         self.now_on_create = now_on_create
-        super(EmFieldDatetime, self).__init__(ftype='datetime',**kwargs)
+        super(EmFieldType, self).__init__(ftype='datetime',**kwargs)
 

EditorialModel/fieldtypes/file.py

 #-*- coding: utf-8 -*-
 
-from EditorialModel.fields import EmField
+from EditorialModel.fieldtypes import GenericFieldType
 
 
-class EmFieldFile(EmField):
+class EmFieldType(GenericFieldType):
 
     help = 'A file field. With one options upload_path'
 
     # @brief max_length int : The maximum length of this field
     def __init__(self, upload_path=None, **kwargs):
         self.upload_path = upload_path
-        super(EmFieldFile, self).__init__(ftype='char',**kwargs)
+        super(EmFieldType, self).__init__(ftype='char',**kwargs)
 

EditorialModel/fieldtypes/generic.py

 #-*- coding: utf-8 -*-
 
 import types
+import importlib
 
 ## @brief Abstract class representing a fieldtype
 class GenericFieldType(object):
     # @throw NotImplementedError if called directly
     # @throw AttributeError if bad ftype
     # @throw AttributeError if bad check_function
-    def __init__(self, ftype, default = None, nullable = False, check_function = None, **kwargs):
+    def __init__(self, ftype, default = None, nullable = True, check_function = None, uniq = False, **kwargs):
         if self.__class__ == GenericFieldType:
             raise NotImplementedError("Abstract class")
         
 
         self.ftype = ftype
         self.check_function = check_function
-        self.nullalble = bool(nullable)
+        self.nullable = bool(nullable)
+        self.uniq = bool(uniq)
 
         self.check_or_raise(default)
         self.default = default
     @staticmethod
     def dummy_check(value):
         pass
+
+    ## @brief Given a fieldtype name return the associated python class
+    # @return An GenericFieldType derivated class
+    @staticmethod
+    def from_name(name):
+        module_name = 'EditorialModel.fieldtypes.%s'%(name)
+        mod = importlib.import_module(module_name)
+        return mod.EmFieldType
+
     
     ## @brief Transform a value into a valid python representation according to the fieldtype
     # @param value ? : The value to cast

EditorialModel/fieldtypes/int.py

-#-*- coding: utf-8 -*-
-
-from EditorialModel.fieldtypes import GenericFieldType
-
-
-class EmFieldInt(GenericFieldType):
-
-    help = 'Basic integer field'
-
-    def __init__(self, **kwargs):
-        super(EmFieldInt, self).__init__(ftype='int',**kwargs)
-
-fclass = EmFieldInt

EditorialModel/fieldtypes/integer.py

+#-*- coding: utf-8 -*-
+
+from EditorialModel.fieldtypes.generic import GenericFieldType
+
+
+class EmFieldType(GenericFieldType):
+
+    help = 'Basic integer field'
+
+    def __init__(self, **kwargs):
+        super(EmFieldType, self).__init__(ftype='int',**kwargs)

EditorialModel/fieldtypes/regexchar.py

 #-*- coding: utf-8 -*-
 
 import re
-from EditorialModel.fieldtypes.generic import GenericFieldType
+import EditorialModel.fieldtypes.char.EmFieldType
 
-
-class EmFieldCharRegex(EmFieldChar):
+class EmFieldType(EditorialModel.fieldtypes.char.EmFieldType):
 
     help = 'String field validated with a regex. Take two optionss : max_length and regex'
 
         def re_match(value):
             if not v_re.match(regex, value):
                 raise TypeError('"%s" don\'t match the regex "%s"'%(value, regex))
-        super(EmFieldCharRegex, self).__init__(check_function=re_match,**kwargs)
+        super(EmFieldType, self).__init__(check_function=re_match,**kwargs)
 

EditorialModel/fieldtypes/rel2type.py

 
 from EditorialModel.fieldtypes.generic import GenericFieldType
 
-class EmFieldRel2Type(GenericFieldType):
+class EmFieldType(GenericFieldType):
 
     help = 'Relationnal field (relation2type). Take rel_to_type_id as option (an EmType uid)'
 
     def __init__(self, rel_to_type_id, **kwargs):
         self.rel_to_type_id = rel_to_type_id
-        super(EmFieldRel2Type, self).__init__(ftype='rel2type',**kwargs)
+        super(EmFieldType, self).__init__(ftype='rel2type',**kwargs)
 
     def get_related_type(self):
         return self.model.component(self.rel_to_type_id)

EditorialModel/fieldtypes/text.py

 
 from EditorialModel.fieldtypes.generic import GenericFieldType
 
-class EmFieldText(GenericFieldType):
+class EmFieldType(GenericFieldType):
 
     help = 'A text field (big string)'
 
     def __init__(self, **kwargs):
-        super(EmFieldText, self).__init__(ftype='text',**kwargs)
+        super(EmFieldType, self).__init__(ftype='text',**kwargs)
 

EditorialModel/model.py

 
     @staticmethod
     ## Given a python class return a name
-    # @param cls : The python class we want the name
+    # @param em_class : The python class we want the name
     # @return A class name as string or False if cls is not an EmComponent child class
-    # @todo réécrire le split, c'est pas bô
     def name_from_emclass(em_class):
         if em_class not in Model.components_class:
-            if issubclass(em_class, EmField):
-                return 'EmField'
             return False
         return em_class.__name__
 
             cls_name = kwargs['component']
             del kwargs['component']
 
-            if cls_name == 'EmField':
-                #Special EmField process because of fieldtypes
-                if not 'fieldtype' in kwargs:
-                    raise AttributeError("Missing 'fieldtype' from EmField instanciation")
-                cls = EditorialModel.fields.EmField.get_field_class(kwargs['fieldtype'])
-            else:
-                cls = self.emclass_from_name(cls_name)
+            cls = self.emclass_from_name(cls_name)
 
             if cls:
                 kwargs['uid'] = uid
         
         if component_type not in [ n for n in self._components.keys() if n != 'uids' ]:
             raise ValueError("Invalid component_type rpovided")
-        elif component_type == 'EmField':
-            #special process for EmField
-            if not 'fieldtype' in datas:
-                raise AttributeError("Missing 'fieldtype' from EmField instanciation")
-            em_obj = EditorialModel.fields.EmField.get_field_class(datas['fieldtype'])
         else:
             em_obj = self.emclass_from_name(component_type)
 

EditorialModel/test/test_model.py

 from EditorialModel.types import EmType
 from EditorialModel.fieldgroups import EmFieldGroup
 from EditorialModel.fields import EmField
-from EditorialModel.fieldtypes.char import EmFieldChar
 from EditorialModel.components import EmComponent
 from Lodel.utils.mlstring import MlString
 
 
 from EditorialModel.backend.json_backend import EmBackendJson
 from EditorialModel.backend.dummy_backend import EmBackendDummy
-from EditorialModel.migrationhandler.django import DjangoMigrationHandler
 from EditorialModel.migrationhandler.dummy import DummyMigrationHandler
 
 
         model = Model(EmBackendJson('EditorialModel/test/me.json'))
         self.assertTrue(isinstance(model, Model))
 
-        model = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DjangoMigrationHandler('LodelTestInstance', debug=False, dryrun=True))
+        model = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler('LodelTestInstance'))
         self.assertTrue(isinstance(model, Model))
 
     def test_bad_init(self):
                 },
             },
             'EmField': {
-                'cls': EmFieldChar,
+                'cls': EmField,
                 'cdats': {
                     'name': 'FooField',
                     'fieldgroup_id': self.ed_mod.components(EmFieldGroup)[0].uid,
     def test_hash(self):
         """ Test that __hash__ and __eq__ work properly on models """
         me1 = Model(EmBackendJson('EditorialModel/test/me.json'))
-        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DjangoMigrationHandler('LodelTestInstance', debug=False, dryrun=True))
+        me2 = Model(EmBackendJson('EditorialModel/test/me.json'), migration_handler=DummyMigrationHandler('LodelTestInstance'))
 
         self.assertEqual(hash(me1), hash(me2), "When instanciate from the same backend & file but with another migration handler the hashes differs")
         self.assertTrue(me1.__eq__(me2))