Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

globconf.d/global.ini

 [lodel2]
 lib_path = /home/yannweb/dev/lodel2/lodel2-git
 plugins_path = /home/yannweb/dev/lodel2/lodel2-git/plugins
+
+[lodel2.editorialmodel]
+emfile = examples/em_test.pickle
+emtranslator = picklefile
+dyncode = lodel/leapi/dyncode.py
+editormode = True
+groups = 

lodel/datasource/generic/__init__.py

+# -*- coding: utf-8 -*-

lodel/datasource/generic/datasource.py

+# -*- coding: utf-8 -*-
+
+class GenericDataSource(object):
+
+    def __init__(self, *conn_args, **conn_kwargs):
+        self.conn_args = conn_args
+        self.conn_kwargs = conn_kwargs
+
+    ## @brief returns a selection of documents from the datasource
+    # @param target_cls Emclass
+    # @param field_list list
+    # @param filters list : List of filters
+    # @param rel_filters list : List of relational filters
+    # @param order list : List of column to order. ex: order = [('title', 'ASC'),]
+    # @param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),]
+    # @param limit int : Number of records to be returned
+    # @param offset int: used with limit to choose the start record
+    # @param instanciate bool : If true, the records are returned as instances, else they are returned as dict
+    # @return list
+    def select(self, target_cls, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0,
+               instanciate=True):
+        pass
+
+    ## @brief Deletes one record defined by its uid
+    # @param target_cls Emclass : class of the record to delete
+    # @param uid dict|list : a dictionary of fields and values composing the unique identifier of the record or a list of several dictionaries
+    # @return int : number of deleted records
+    def delete(self, target_cls, uid):
+        pass
+
+    ## @brief updates one or a list of records
+    # @param target_cls Emclass : class of the object to insert
+    # @param uids list : list of uids to update
+    # @param datas dict : datas to update (new values)
+    # @return int : Number of updated records
+    def update(self, target_cls, uids, **datas):
+        pass
+
+    ## @brief Inserts a record in a given collection
+    # @param target_cls Emclass : class of the object to insert
+    # @param datas dict : datas to insert
+    # @return bool
+    def insert(self, target_cls, **datas):
+        pass
+
+    ## @brief Inserts a list of records in a given collection
+    # @param target_cls Emclass : class of the objects inserted
+    # @param datas_list
+    # @return list : list of the inserted records' ids
+    def insert_multi(self, target_cls, datas_list):
+        pass

lodel/datasource/mongodb/datasource.py

 
 import lodel.datasource.mongodb.utils as utils
 
+from lodel.datasource.generic.datasource import GenericDataSource
+
 
 class MongoDbDataSourceError(Exception):
     pass
 
 
-class MongoDbDataSource(object):
+class MongoDbDataSource(GenericDataSource):
 
     MANDATORY_CONNECTION_ARGS = ('host', 'port', 'login', 'password', 'dbname')
 

lodel/datasource/mongodb/utils.py

     '>': {'name': '$gt', 'value_type': None},
     'in': {'name': '$in', 'value_type': list},
     'not in': {'name': '$nin', 'value_type': list},
-    #' like ': {'name': '$text', 'value_type': str},
-    #' not like ': {'name': '', 'value_type': str},  # TODO Add the operator
     'OR': {'name': '$or', 'value_type': list},
     'AND': {'name': '$and', 'value_type': list}
 }

lodel/editorial_model/components.py

         self.__fields = dict() 
     
     ##@brief Property that represent a dict of all fields (the EmField defined in this class and all its parents)
+    # @todo use Settings.editorialmodel.groups to determine wich fields should be returned
     @property
     def __all_fields(self):
         res = dict()
     # @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 A list on EmFields instances (if uid is None) else return an EmField instance
+    # @todo use Settings.editorialmodel.groups to determine wich fields should be returned
     def fields(self, uid = None, no_parents = False):
         fields = self.__fields if no_parents else self.__all_fields
         try:
                     res[new_app.uid] = new_app
         return res
     
-	##@brief Returns EmGroup components
+    ##@brief Returns EmGroup components
     # @returns a copy of the set of components
     def components(self):
         return (self.__components).copy()

lodel/leapi/datahandlers/base_classes.py

             if self.max_item < len(value):
                 return None, FieldValidationError("To many items")
 
+## @brief Class designed to handle datas access will fieldtypes are constructing datas
+#
+# This class is designed to allow automatic scheduling of construct_data calls. 
+#
+# In theory it's able to detect circular dependencies
+# @todo test circular deps detection
+# @todo test circulat deps false positiv
+class DatasConstructor(object):
+    
+    ## @brief Init a DatasConstructor
+    # @param lec LeCrud : @ref LeObject child class 
+    # @param datas dict : dict with field name as key and field values as value
+    # @param fields_handler dict : dict with field name as key and data handler instance as value
+    def __init__(self, leobject, datas, fields_handler):
+        ## Stores concerned class
+        self._leobject = leobject
+        ## Stores datas and constructed datas
+        self._datas = copy.copy(datas)
+        ## Stores fieldtypes
+        self._fields_handler = fields_handler
+        ## Stores list of fieldname for constructed datas
+        self._constructed = []
+        ## Stores construct calls list
+        self._construct_calls = []
+    
+    ## @brief Implements the dict.keys() method on instance
+    def keys(self):
+        return self._datas.keys()
+    
+    ## @brief Allows to access the instance like a dict
+    def __getitem__(self, fname):
+        if fname not in self._constructed:
+            if fname in self._construct_calls:
+                raise RuntimeError('Probably circular dependencies in fieldtypes')
+            cur_value = self._datas[fname] if fname in self._datas else None
+            self._datas[fname] = self._fields_handler[fname].construct_data(self._leobject, fname, self, cur_value)
+            self._constructed.append(fname)
+        return self._datas[fname]
+    
+    ## @brief Allows to set instance values like a dict
+    # @warning Should not append in theory
+    def __setitem__(self, fname, value):
+        self._datas[fname] = value
+        warnings.warn("Setting value of an DatasConstructor instance")
+ 

lodel/settings/settings.py

 #
 # @todo handles default sections for variable sections (sections ending with 
 # '.*')
+# @todo delete the first stage, the lib path HAVE TO BE HARDCODED. In fact
+#when we will run lodel in production the lodel2 lib will be in the python path
 class Settings(object):
     
     ##@brief global conf specsification (default_value + validator)

lodel/settings/validator.py

                     SettingValidator('bool')),
         'plugins': (    "",
                         SettingValidator('list')),
+        'sitename': (   'noname',
+                        SettingValidator('strip')),
     },
     'lodel2.logging.*' : {
         'level': (  'ERROR',
                             SettingValidator('int', none_is_valid = True)),
         'maxbytes': (   None,
                         SettingValidator('int', none_is_valid = True)),
+    },
+    'lodel2.editorialmodel': {
+        'emfile': ( 'em.pickle',
+                    SettingValidator('strip')),
+        'emtranslator': (   'picklefile',
+                            SettingValidator('strip')),
+        'dyncode': (    'leapi_dyncode.py',
+                        SettingValidator('strip')),
+        'groups': ( '',
+                    SettingValidator('list')),
+        'editormode': ( False,
+                        SettingValidator('bool')),
     }
 }

tests/settings/settings_examples/complex.conf.d/file1.ini

+[lodel2.editorialmodel]
+lib_path=/tmp
+foo_bar=42
+foo.bar=1337
+[lodel2.bar.foo]
+barfoo=42
+[lodel2.bar.bar]
+toto=tata

tests/settings/settings_examples/complex.conf.d/file2.ini

+[lodel2.editorialmodel]
+example=foobar
+
+[lodel2.conf1]
+conf_key=woot
+conf_value=42
+
+[lodel2.conf2]
+conf_foo=bar

tests/settings/settings_examples/complex.conf.d/file3.ini

+[lodel2.foo.bar]
+barfoo=42
+[lodel2.foo.foo]
+foobar=barfoo
+[lodel2.bar.foo]
+foobar=barfoo

tests/settings/test_settings.py

 
 class SettingsTestCase(unittest.TestCase):
     
+    @unittest.skip('todo : write it')
     def test_init(self):
         settings = Settings('tests/settings/settings_tests.ini', 'tests/settings/settings_tests_conf.d')
         pass

tests/settings/test_settings_loader.py

         value = loader.getoption('lodel2.foo.bar', 'foobar', dummy_validator)
         self.assertEqual(value, "hello world")
 
+    def test_getoption_complex(self):
+        """ Testing behavior of getoption with less simple files & confs """
+
+        expected = {
+            'lodel2.editorialmodel': {
+                'lib_path': '/tmp',
+                'foo_bar': '42',
+                'foo.bar': '1337',
+                'example': 'foobar',
+            },
+            'lodel2.conf1': {
+                'conf_key': 'woot',
+                'conf_value': '42',
+            },
+            'lodel2.conf2': {
+                'conf_foo': 'bar',
+            },
+            'lodel2.foo.foo': {
+                'foobar': 'barfoo',
+            },
+            'lodel2.bar.foo': {
+                'foobar': 'barfoo',
+                'barfoo': '42',
+            },
+            'lodel2.bar.bar': {
+                'toto': 'tata',
+            }
+        }
+
+        loader = SettingsLoader('tests/settings/settings_examples/complex.conf.d')
+        for section in expected:
+            for key, expected_value in expected[section].items():
+                value = loader.getoption(   section,
+                                            key,
+                                            dummy_validator)
+                self.assertEqual(value, expected_value)
+
+                
+
     def test_variable_sections(self):
         """ Testing variable section recognition """
         loader = SettingsLoader('tests/settings/settings_examples/var_sections.conf.d')