lorj 0.2.0 → 1.0.0

data/lib/core/core.rb

@@ -15,708 +15,368 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
+# rubocop: disable Metrics/AbcSize
+
 # Module Lorj which contains several classes.
 #
 # Those classes describes :
 # - processes (BaseProcess)   : How to create/delete/edit/query object.
-# - controler (BaseControler) : If a provider is defined, define how will do object creation/etc...
-# - definition(BaseDefinition): Functions to declare objects, query/data mapping and setup
+# - controler (BaseControler) : If a provider is defined, define how will do
+#                               object creation/etc...
+# - definition(BaseDefinition): Functions to declare objects, query/data mapping
+#                               and setup
 # this task to make it to work.
-
 module Lorj
-
-   # Internal Lorj function to debug lorj.
-   #
-   # * *Args* :
-   #   - +iLevel+ : value between 1 to 5. Setting 5 is the most verbose!
-   #   - +sMsg+   : Array of string or symbols. keys tree to follow and check existence in yVal.
-   #
-   # * *Returns* :
-   #   - nothing
-   #
-   # * *Raises* :
-   #   No exceptions
-   def Lorj::debug(iLevel, sMsg)
-      if iLevel <= PrcLib.core_level
-         PrcLib.debug("-%s- %s" % [iLevel, sMsg])
-      end
-   end
-
-   # Internal PrcError class object derived from RuntimeError.
-   # Internally used with raise.
-   # Used to identify the error origin, while an error is thrown.
-   class PrcError < RuntimeError
-      attr_reader :ForjMsg
-
-      def initialize(message = nil)
-         @ForjMsg = message
-      end
-   end
-
-
-   # This is the main lorj class.
-   # It interfaces your main code with the full lorj system as shown in the concept document.
-   # It give you access to the lorj model object designed by your process.
-   #
-   # When you start using it, your main must be as simple as you can, as you will need to move
-   # most of your application logic to the process.
-   # Your application can have several lorj objects running in your code, depending of your needs.
-   #
-   # The main things is that you can move most of your process management, usually in your code/modules
-   # to be part of the lorj process, make it controller independant, and gains in
-   # implementing several controllers to change the way to implement but not the process
-   # you used to build your application!
-   #
-   # Then, your application contributors can build their own controller and extend your solution!
-   #
-   # Here an example of creating a CloudServer, using CloudCore (derived from Core).
-   # CloudCore introduces lorj predefined CloudProcess used by forj cli.
-   #
-   #   oCloud = Lorj::CloudCore.new(oConfig, 'myhpcloud')
-   #   oConfig.set(:server_name,'myservername')
-   #   oCloud.Create(:server)
-   #
-   # Another basic example (See example directory)
-   #
-   #   oConfig = Lorj::Account.new()
-   #   oPrc = Lorj::Core.new(oConfig, 'mySqlAccount')
-   #   oCloud.Create(:student, { :student_name => "Robert Redford"})
-   #
-   # See BaseProcess to check how you can write a process and what kind of functions
-   # are available for your process to be kept controller independant.
-   #
-   # See BaseController to see how you can write a controller and what kind of functions
-   # are available to deal with the implementation API you need to use.
-   class Core
-
-      # Public access to a config object.
-      # A config object can be any kind of class which should provide at least following functions:
-      #
-      # - get(*key, default=nil) and [*key]  : function to get a value from a key. default is a value to get if not found.
-      # - set(*key, value) or [*key, value]= : function to set a value to a key.
-      #   Ex: From processes, you can set a runtime data with:
-      #
-      #      config.set(key, value)
-      #
-      #   OR
-      #
-      #      config[key] = value
-      #
-      # - exist?(*key)                       : function which return false if not found, or any other value if found.
-      #   Ex: From processes, you can get a data (runtime/account/config.yaml or defaults.yaml) with:
-      #
-      #      config.get(key)
-      #
-      #   OR
-      #
-      #      config[key]
-      #
-      # For each functions, *key is a list of value, which becomes an array in the function.
-      # It should accept to manage the key tree (hash of hashes)
-      #
-      # Currently lorj comes with Lorj::Config or Lorj::Account.
-      # Thoses classes defines at least those 5 functions. And more.
-      attr_reader :config
-
-      # Core parameters are:
-      # oForjConfig : Optional. An instance of a configuration system which *HAVE* to provide get/set/exist?/[]/[]=
-      #
-      # processClass: Array of string or symbol, or string or symbol. Is the path or name of one or more ProcessClass to use.
-      #   This class is dynamically loaded and derived from BaseProcess class.
-      #   It loads the Process class content from a file '$CORE_PROCESS_PATH/<sProcessClass>.rb'
-      #   If sProcessClass is a file path, this file will be loaded as a ruby include.
-      #
-      #   <sProcessClass>.rb file name is case sensible and respect RUBY Class name convention
-      #
-      # sControllerClass: Optional. string or symbol. Is the path or name of ControllerClass to use.
-      #   This class is dynamically loaded and derived from BaseController class.
-      #   It loads the Controler class content from a file '$PROVIDER_PATH/<sControllerClass>.rb'
-      #
-      #   The provider can redefine partially or totally some processes
-      #   Lorj::Core will load those redefinition from file:
-      #   $PROVIDER_PATH/<sControlerClass>Process.rb'
-      #
-      # <sControllerClass>.rb or <sControllerClass>Process.rb file name is case sensible and respect RUBY Class name convention
-
-      def initialize(oForjConfig = nil, processesClass = nil, sControllerClass = nil)
-         # Loading ProcessClass
-         # Create Process derived from respectively BaseProcess
-
-         PrcLib.core_level = 0 if PrcLib.core_level.nil?
-
-         if oForjConfig.nil?
-            @config = Lorj::Config.new()
-            oForjConfig = @config
-            Lorj.debug(2, "Using an internal Lorj::Config object.")
-         else
-            @config = oForjConfig
-         end
-
-
-         if processesClass.nil?
-            aProcessesClass = []
-         elsif not processesClass.is_a?(Array)
-            aProcessesClass = [processesClass]
-         else
-            aProcessesClass = processesClass
-         end
-
-         cBaseProcess = BaseProcess
-         cProcessClass = nil
-
-         aProcessesClass.each { | sProcessClass |
-            Lorj.debug(1, "Loading Process '%s'" % sProcessClass)
-
-            # And load the content from the <sProcessClass>.rb
-            if sProcessClass.is_a?(Symbol)
-               # Ensure file and processName is capitalized
-               sProcessClass = sProcessClass.to_s
-               sProcessClass = sProcessClass.capitalize if (/[A-Z]/ =~ sProcessClass.to_s) != 0
-               sFile = File.join(PrcLib.process_path, sProcessClass + '.rb')
-            else
-               if sProcessClass.include?('/')
-                  # Consider a path to the process file. File name is the name of the class.
-                  # We accept filename not capitalized.
-                  sPath = File.dirname(File.expand_path(sProcessClass))
-                  sFile = File.basename(sProcessClass)
-                  file = File.basename(sProcessClass)
-                  file['.rb'] = '' if file['.rb']
-                  sProcessClass = file
-                  sProcessClass = sProcessClass.capitalize if (/[A-Z]/ =~ sProcessClass) != 0
-                  mFound = sProcessClass.scan(/_[a-z]/)
-                  if mFound
-                     mFound.each { | str |
-                        sProcessClass[str] = str[1].capitalize
-                     }
-                  end
-               else
-                  sPath = PrcLib.process_path
-                  sProcessClass = sProcessClass.capitalize if (/[A-Z]/ =~ sProcessClass) != 0
-                  sFile = sProcessClass + '.rb'
-               end
-               # Ensure process name is capitalized
-               sFile = File.join(sPath, sFile)
-            end
-            if File.exists?(sFile)
-               cNewClass = Class.new(cBaseProcess)
-               sProcessClass = "%sProcess" %  sProcessClass if not /Process$/ =~ sProcessClass
-               Lorj.debug(1, "Declaring Process '%s'" % sProcessClass)
-               cBaseProcess = Object.const_set(sProcessClass, cNewClass)
-               cProcessClass = sProcessClass
-               BaseDefinition.current_process(cBaseProcess)
-               load sFile
-            else
-               PrcLib.warning("Process file definition '%s' is missing. " % sFile)
-            end
-         }
-
-         if sControllerClass
-            Lorj.debug(1, "Loading Controller/definition '%s'" % sControllerClass)
-            # Add Provider Object -------------
-            if sControllerClass.is_a?(Symbol)
-               sPath = File.join(PrcLib.controller_path, sControllerClass.to_s)
-               sControllerClass = sControllerClass.to_s.capitalize if (/[A-Z]/ =~ sControllerClass.to_s) != 0
-               sFile = sControllerClass.to_s + '.rb'
-            else
-               if sControllerClass.include?('/')
-                  # Consider a path to the process file. File name is the name of the class.
-                  sPath = File.dirname(File.expand_path(sControllerClass))
-                  sFile = File.basename(sControllerClass)
-                  file = File.basename(sControllerClass)
-                  file = file.capitalize if (/[A-Z]/ =~ file) != 0
-                  file['.rb'] = '' if file['.rb']
-                  sControllerClass = file
-                  sControllerClass = sControllerClass.capitalize if (/[A-Z]/ =~ sControllerClass) != 0
-                  mFound = sControllerClass.scan(/_[a-z]/)
-                  if mFound
-                     mFound.each { | str |
-                        sControllerClass[str] = str[1].capitalize
-                     }
-                  end
-               else
-                  sPath = File.join(PrcLib.controller_path, sControllerClass)
-                  sControllerClass = sControllerClass.capitalize if (/[A-Z]/ =~ sControllerClass) != 0
-                  sFile = sControllerClass + '.rb'
-               end
-            end
-            sFile = File.join(sPath, sFile)
-
-            # Initialize an empty class derived from BaseDefinition.
-            # This to ensure provider Class will be derived from this Base Class
-            # If this class is derived from a different Class, ruby will raise an error.
-
-            # Create Definition and Controler derived from respectively BaseDefinition and BaseControler
-            cBaseDefinition = Class.new(BaseDefinition)
-            # Finally, name that class!
-            Lorj.debug(2, "Declaring Definition '%s'" % sControllerClass)
-            Object.const_set sControllerClass, cBaseDefinition
-
-            cBaseControler = Class.new(BaseController)
-            Lorj.debug(2, "Declaring Controller '%s'" % [sControllerClass + 'Controller'])
-            Object.const_set sControllerClass + 'Controller', cBaseControler
-
-            # Loading Provider base file. This file should load a class
-            # which have the same name as the file.
-            if File.exists?(sFile)
-               load sFile
-            else
-               raise Lorj::PrcError.new(), "Provider file definition '%s' is missing. Cannot go on" % sFile
-            end
-
-            # Identify Provider Classes. Search for
-            # - Definition Class (sControllerClass) - Contains ForjClass Object
-            # - Controller Class (sControllerClass + 'Controller') - Provider Cloud controler object
-
-            # Search for Definition Class
-            begin
-               # Get it from Objects
-               oDefClass = Object.const_get(sControllerClass)
-            rescue
-               raise Lorj::PrcError.new(), 'Lorj::Core: Unable to find class "%s"' % sControllerClass
-            end
-
-            # Search for Controler Class
-            # - Process Class (sControllerClass + 'Process') - Provider Process object if defined
-            begin
-               # Get the same one suffixed with 'Provider' from Objects
-               oCoreObjectControllerClass = Object.const_get(sControllerClass + 'Controller')
-            rescue
-               raise Lorj::PrcError.new(), 'Lorj::Core: Unable to find class "%s"' % sControllerClass + 'Controller'
-            end
-
-            # Then, we create an BaseCloud Object with 2 objects joined:
-            # ForjAccount and a BaseControler Object type
-
-
-         else
-            oCoreObjectControllerClass = nil
-            oDefClass = BaseDefinition
-         end
-
-         # Add Process management object ---------------
-         unless cProcessClass.nil?
-            begin
-               oBaseProcessDefClass = Object.const_get(cProcessClass)
-            rescue
-               raise Lorj::PrcError.new(), 'Lorj::Core: Unable to find class "%s"' % cProcessClass
-            end
-         else
-            raise Lorj::PrcError.new(), 'Lorj::Core: No valid process loaded. Aborting.'
-         end
-         # Ex: Hpcloud(ForjAccount, HpcloudProvider)
-         if oCoreObjectControllerClass
-            @oCoreObject = oDefClass.new(oForjConfig, oBaseProcessDefClass.new(), oCoreObjectControllerClass.new())
-         else
-            @oCoreObject = oDefClass.new(oForjConfig, oBaseProcessDefClass.new())
-         end
-
-      end
-
-      # a wrapper to Create call. Use this function for code readibility.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Connect(oCloudObj, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-         @oCoreObject.Create(oCloudObj, hConfig)
-      end
-
-      # Execute the creation process to create the object `oCloudObj`.
-      # The creation process can add any kind of complexity to
-      # get the a memory representation of the object manipulated during creation process.
-      # This means that a creation process can be (non exhaustive list of possibilities)
-      # - a connection initialization
-      # - an internal memory data structure, like hash, array, ruby object...
-      # - a get or create logic
-      # - ...
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-      def Create(oCloudObj, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-         @oCoreObject.Create(oCloudObj, hConfig)
-      end
-
-      # a wrapper to Create call. Use this function for code readibility.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def GetOrCreate(oCloudObj, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-         @oCoreObject.Create(oCloudObj, hConfig)
+  # This is the main lorj class.
+  # It interfaces your main code with the full lorj system as shown in the
+  # concept document.
+  # It give you access to the lorj model object designed by your process.
+  #
+  # When you start using it, your main must be as simple as you can, as you will
+  # need to move most of your application logic to the process.
+  # Your application can have several lorj objects running in your code,
+  # depending of your needs.
+  #
+  # The main things is that you can move most of your process management,
+  # usually in your code/modules to be part of the lorj process, make it
+  # controller independant, and gains in implementing several controllers to
+  # change the way to implement but not the process, you used to build your
+  # application!
+  #
+  # Then, your application contributors can build their own controller and
+  # extend your solution!
+  #
+  # Here an example of creating a CloudServer, using CloudCore
+  # (derived from Core).
+  # CloudCore introduces lorj predefined CloudProcess used by forj cli.
+  #
+  #   oCloud = Lorj::CloudCore.new(oConfig, 'myhpcloud')
+  #   oConfig.set(:server_name,'myservername')
+  #   oCloud.Create(:server)
+  #
+  # Another basic example (See example directory)
+  #
+  #   oConfig = Lorj::Account.new()
+  #   oPrc = Lorj::Core.new(oConfig, 'mySqlAccount')
+  #   oCloud.Create(:student, { :student_name => "Robert Redford"})
+  #
+  # See BaseProcess to check how you can write a process and what kind of
+  # functions are available for your process to be kept controller independant.
+  #
+  # See BaseController to see how you can write a controller and what kind of
+  # functions are available to deal with the implementation API you need to use.
+  class Core
+    # Public access to a config object.
+    # A config object can be any kind of class which should provide at least
+    # following functions:
+    #
+    # - get(*key, default=nil) and [*key]  : function to get a value from a key.
+    #                                        default is a value to get if not
+    #                                        found.
+    # - set(*key, value) or [*key, value]= : function to set a value to a key.
+    #   Ex: From processes, you can set a runtime data with:
+    #
+    #      config.set(key, value)
+    #
+    #   OR
+    #
+    #      config[key] = value
+    #
+    # - exist?(*key)                       : function which return false if not
+    #                                        found, or any other value if found.
+    #   Ex: From processes, you can get a data (runtime/account/config.yaml or
+    #       defaults.yaml) with:
+    #
+    #      config.get(key)
+    #
+    #   OR
+    #
+    #      config[key]
+    #
+    # For each functions, *key is a list of value, which becomes an array in the
+    # function.
+    # It should accept to manage the key tree (hash of hashes)
+    #
+    # Currently lorj comes with Lorj::Config or Lorj::Account.
+    # Thoses classes defines at least those 5 functions. And more.
+    attr_reader :config
+
+    # a wrapper to Create call. Use this function for code readibility.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def connect(oCloudObj, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+      @core_object.process_create(oCloudObj, hConfig)
+    end
+
+    # Execute the creation process to create the object `oCloudObj`.
+    # The creation process can add any kind of complexity to
+    # get the a memory representation of the object manipulated during creation
+    # process.
+    # This means that a creation process can be (non exhaustive list of
+    # possibilities)
+    # - a connection initialization
+    # - an internal memory data structure, like hash, array, ruby object...
+    # - a get or create logic
+    # - ...
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+    def create(oCloudObj, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+      @core_object.process_create(oCloudObj, hConfig)
+    end
+
+    # a wrapper to Create call. Use this function for code readibility.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def get_or_create(oCloudObj, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+      @core_object.process_create(oCloudObj, hConfig)
+    end
+
+    # Execution of the delete process for the `oCloudObj` object.
+    # It requires the object to be loaded in lorj Lorj::Data objects cache.
+    # You can use `Create` or `Get` functions to load this object.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def delete(oCloudObj, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+
+      @core_object.process_delete(oCloudObj, hConfig)
+    end
+
+    # Execution of the Query process for the `oCloudObj` object.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +sQuery+    : Hash representing the query filter.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def query(oCloudObj, sQuery, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+
+      @core_object.process_query(oCloudObj, sQuery, hConfig)
+    end
+
+    # Execution of the Get process for the `oCloudObj` object.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +sId+       : data representing the ID (attribute :id) of a Lorj::Data
+    #                   object.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def get(oCloudObj, sId, hConfig = {})
+      return nil if !oCloudObj || !@core_object || sId.nil?
+
+      @core_object.process_get(oCloudObj, sId, hConfig)
+    end
+
+    # Execution of the Update process for the `oCloudObj` object.
+    # Usually, the Controller object data is updated by the process
+    # (BaseController::set_attr)
+    # then it should call a controller_update to really update the data in the
+    # controller.
+    #
+    # * *Args* :
+    #   - +oCloudObj+ : Name of the object to initialize.
+    #   - +sId+       : data representing the ID (attribute :id) of a Lorj::Data
+    #                   object.
+    #   - +hConfig+   : Hash of hashes containing data required to initialize
+    #                   the object.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def update(oCloudObj, hConfig = {})
+      return nil if !oCloudObj || !@core_object
+
+      @core_object.process_update(oCloudObj, hConfig)
+    end
+
+    # Function used to ask users about setting up his account.
+    #
+    # * *Args* :
+    #   - +oCloudObj+    : Name of the object to initialize.
+    #   - +sAccountName+ : Account file name. If not set, Config[:account_name]
+    #                      is used.
+    #     If you use this variable, any other runtime config defined
+    #     by the Data model will be cleaned before
+    #
+    # * *Returns* :
+    #   - +Lorj::Data+ : Represents the Object initialized.
+    #
+    # * *Raises* :
+    #   No exceptions
+
+    def setup(oCloudObj, sAccountName = nil)
+      return nil if !oCloudObj || !@core_object
+      @core_object.process_setup(oCloudObj, sAccountName)
+    end
+
+    # Core parameters are:
+    # the_config : Optional. An instance of a configuration system which *HAVE*
+    # to provide get/set/exist?/[]/[]=
+    #
+    # processClass: Array of string or symbol, or string or symbol. Is the path
+    # or name of one or more ProcessClass to use.
+    #   This class is dynamically loaded and derived from BaseProcess class.
+    #   It loads the Process class content from a file
+    #   '$CORE_PROCESS_PATH/<process_class>.rb'
+    #   If process_class is a file path, this file will be loaded as a ruby
+    #   include.
+    #
+    #   <process_class>.rb file name is case sensible and respect RUBY Class
+    #   name convention
+    #
+    # controller_class: Optional. string or symbol. Is the path or name of
+    #                   ControllerClass to use.
+    #   This class is dynamically loaded and derived from BaseController class.
+    #   It loads the Controler class content from a file
+    #   '$PROVIDER_PATH/<controller_class>.rb'
+    #
+    #   The provider can redefine partially or totally some processes
+    #   Lorj::Core will load those redefinition from file:
+    #   $PROVIDER_PATH/<controller_class>Process.rb'
+    #
+    # <controller_class>.rb or <controller_class>Process.rb file name is case
+    # sensible and respect RUBY Class name convention
+    def initialize(the_config = nil, the_process_class = nil,
+                   controller_class = nil)
+      # Loading ProcessClass
+      # Create Process derived from respectively BaseProcess
+      PrcLib.core_level = 0 if PrcLib.core_level.nil?
+
+      init_core_config(the_config)
+
+      model = initialize_model
+
+      # Load Application processes
+      init_processes(model, the_process_class)
+
+      fail Lorj::PrcError.new, 'Lorj::Core: No valid process loaded. '\
+                               'Aborting.' if model[:process_class].nil?
+
+      # Load Controller and Controller processes.
+      init_controller(model, controller_class) if controller_class
+
+      # Create Core object with the application model loaded
+      # (processes & controller)
+      initialize_core_object(model)
+      PrcLib.model.clear_heap
+    end
+  end
+
+  # This class based on generic Core, defines a Cloud Process to use.
+  class CloudCore < Core
+    def initialize(oConfig, sAccount = nil, aProcesses = [])
+      config_account = init_config(oConfig, sAccount)
+
+      process_list = [:CloudProcess]
+
+      controller_mod = config_account.get(:provider_name)
+      fail Lorj::PrcError.new, 'Provider_name not set. Unable to create'\
+                               ' instance CloudCore.' if controller_mod.nil?
+
+      init_controller_mod(process_list, controller_mod)
+
+      super(config_account, process_list.concat(aProcesses), controller_mod)
+    end
+
+    private
+
+    def init_config(oConfig, sAccount)
+      if !oConfig.is_a?(Lorj::Account)
+        config_account = oConfig
+      else
+        config_account = Lorj::Account.new(oConfig)
+
+        config_account.ac_load(sAccount) unless sAccount.nil?
       end
-
-      # Execution of the delete process for the `oCloudObj` object.
-      # It requires the object to be loaded in lorj Lorj::Data objects cache.
-      # You can use `Create` or `Get` functions to load this object.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Delete(oCloudObj, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-
-         @oCoreObject.Delete(oCloudObj, hConfig)
-      end
-
-      # Execution of the Query process for the `oCloudObj` object.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +sQuery+    : Hash representing the query filter.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Query(oCloudObj, sQuery, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-
-         @oCoreObject.Query(oCloudObj, sQuery, hConfig)
+      config_account
+    end
+
+    def init_controller_mod(process_list, controller_mod)
+      # TODO: Support for process full path, instead of predefined one.
+      controller_process_mod = File.join(PrcLib.controller_path, controller_mod,
+                                         controller_mod.capitalize +
+                                         'Process.rb')
+      if File.exist?(controller_process_mod)
+        process_list << controller_process_mod
+      else
+        Lorj.debug(1, format("No Provider process defined. File '%s' not "\
+                             'found.', controller_process_mod))
       end
-
-      # Execution of the Get process for the `oCloudObj` object.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +sId+       : data representing the ID (attribute :id) of a Lorj::Data object.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Get(oCloudObj, sId, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject or sId.nil?
-
-         @oCoreObject.Get(oCloudObj, sId, hConfig)
-      end
-
-      # Execution of the Update process for the `oCloudObj` object.
-      # Usually, the Controller object data is updated by the process (BaseController::set_attr)
-      # then it should call a controller_update to really update the data in the controller.
-      #
-      # * *Args* :
-      #   - +oCloudObj+ : Name of the object to initialize.
-      #   - +sId+       : data representing the ID (attribute :id) of a Lorj::Data object.
-      #   - +hConfig+   : Hash of hashes containing data required to initialize the object.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Update(oCloudObj, hConfig = {})
-         return nil if not oCloudObj or not @oCoreObject
-
-         @oCoreObject.Update(oCloudObj, hConfig)
-      end
-
-      # Function used to ask users about setting up his account.
-      #
-      # * *Args* :
-      #   - +oCloudObj+    : Name of the object to initialize.
-      #   - +sAccountName+ : Account file name. If not set, Config[:account_name] is used.
-      #     If you use this variable, any other runtime config defined
-      #     by the Data model will be cleaned before
-      #
-      # * *Returns* :
-      #   - +Lorj::Data+ : Represents the Object initialized.
-      #
-      # * *Raises* :
-      #   No exceptions
-
-      def Setup(oCloudObj, sAccountName = nil)
-         return nil if not oCloudObj or not @oCoreObject
-         @oCoreObject.Setup(oCloudObj, sAccountName)
-      end
-   end
-
-   # This class based on generic Core, defines a Cloud Process to use.
-   class CloudCore < Core
-      def initialize(oConfig, sAccount = nil, aProcesses = [])
-
-         unless oConfig.is_a?(Lorj::Account)
-            oForjAccount = Lorj::Account.new(oConfig)
-            unless sAccount.nil?
-               oForjAccount.ac_load(sAccount)
-            end
-         else
-            oForjAccount = oConfig
-         end
-         aProcessList = [:CloudProcess]
-
-         sControllerMod = oForjAccount.get(:provider_name)
-         raise Lorj::PrcError.new(), "Provider_name not set. Unable to create instance CloudCore." if sControllerMod.nil?
-
-         sControllerProcessMod = File.join(PrcLib.controller_path, sControllerMod, sControllerMod.capitalize + "Process.rb")
-         if File.exist?(sControllerProcessMod)
-            aProcessList << sControllerProcessMod
-         else
-            Lorj.debug(1, "No Provider process defined. File '%s' not found." % sControllerProcessMod)
-         end
-
-         super(oForjAccount, aProcessList.concat(aProcesses), sControllerMod)
-      end
-   end
-
-   # Represents a list of key/value pairs
-   # if the value is a Lorj::Data(data or list), the key will be the Lorj::Data type.
-   #
-   #
-   #
-   # Used by
-   # - BaseDefinition to get a Lorj::Data cache.
-   # - Process create/query/update/delete/get to build the hParams
-   #   The object behavior is adapted to the process usage
-   #   By default for Lorj::Data(:object), hParams[aKey] will get or set object attributes
-   #
-   # - Controller create/query/update/delete/get to build the hParams
-   #   The object behavior is adapted to the controller usage
-   #   By default for Lorj::Data(:object), hParams[aKey] will get or set controller object
-   #
-   class ObjectData
-      # Intialize the object. By default, usage is for controller context.
-      #
-      # * *Args* :
-      #   - +bInternal+    : Context
-      #     - true if process context
-      #     - false if controller context. This is the default value.
-      #
-      # * *Returns* :
-      #   - nothing
-      #
-      # * *Raises* :
-      #   No exceptions
-      def initialize(bInternal = false)
-
-         @hParams = {}
-         @hParams[:hdata] = {} unless bInternal
-         @bInternal = bInternal
-      end
-
-      # Get function
-      #
-      # key can be an array, a string (converted to a symbol) or a symbol.
-      #
-      # * *Args*    :
-      #   - +key+   : key tree (list of keys)
-      #     If key[1] == :attrs, get will forcelly use the Lorj::Data object attributes
-      #     If key[1] == :ObjectData, get will forcelly return the controller object
-      #     otherwise, get will depends on the context:
-      #     - controller context: will return the controller object
-      #     - Process context: will return the Lorj::Data object attributes
-      # * *Returns* :
-      #   value found or nil.
-      # * *Raises* :
-      #   nothing
-      def [] (*key)
-
-         key = key.flatten
-         # Return ObjectData Element if asked. Ignore additional keys.
-         return @hParams[key[0]] if key[1] == :ObjectData
-
-         return @hParams if key.length == 0
-
-         oObject = Lorj::rhGet(@hParams, key[0])
-         return nil if oObject.nil?
-
-         # Return attributes if asked
-         return oObject[:attrs,  key[2..-1]] if key[1] == :attrs
-
-         if oObject.is_a?(Lorj::Data)
-            if @bInternal
-               # params are retrieved in process context
-               # By default, if key is detected as a framework object, return its data.
-               return oObject[:attrs,  key[1..-1]]
-            else
-               # params are retrieved in controller context
-               # By default, if key is detected as a controller object, return its data.
-               return oObject[:object,  key[1..-1]]
-            end
-         end
-
-         # otherwise, simply return what is found in keys hierarchy.
-         Lorj::rhGet(@hParams, key)
-      end
-
-      # Functions used to set simple data/Object for controller/process function call.
-      # TODO: to revisit this function, as we may consider simple data, as Lorj::Data object
-      def []= (*key, value)
-         return nil if [:object, :query].include?(key[0])
-         Lorj::rhSet(@hParams, value, key)
-      end
-
-      # Add function. Add a Lorj::Data (data or list) to the ObjectData list.
-      #
-      # key can be an array, a string (converted to a symbol) or a symbol.
-      #
-      # * *Args*    :
-      #   - +oDataObject+ : Lorj::Data object
-      # * *Returns* :
-      #   Nothing
-      # * *Raises* :
-      #   nothing
-      def add(oDataObject)
-         # Requires to be a valid framework object.
-         raise Lorj::PrcError.new, "Invalid Framework object type '%s'." % oDataObject.class unless oDataObject.is_a?(Lorj::Data)
-
-         sObjectType = oDataObject.object_type?
-
-         if oDataObject.type? == :list
-            oOldDataObject = Lorj::rhGet(@hParams, :query, sObjectType)
-            oOldDataObject.unregister if oOldDataObject
-            Lorj::rhSet(@hParams, oDataObject, :query, sObjectType)
-         else
-            oOldDataObject = Lorj::rhGet(@hParams, sObjectType)
-            oOldDataObject.unregister if oOldDataObject
-            @hParams[sObjectType] = oDataObject
-         end
-         oDataObject.register
-      end
-
-      # delete function. delete a Lorj::Data (data or list) from the ObjectData list.
-      #
-      # key can be an array, a string (converted to a symbol) or a symbol.
-      #
-      # * *Args*    :
-      #   - +oDataObject+ : Lorj::Data object
-      # * *Returns* :
-      #   Nothing
-      # * *Raises* :
-      #   nothing
-      def delete(oObj)
-         if oObj.is_a?(Symbol)
-            sObjectType = oObj
-            oObj = @hParams[sObjectType]
-            @hParams[sObjectType] = nil
-         else
-            raise Lorj::PrcError.new(), "ObjectData: delete error. oObj is not a framework data Object. Is a '%s'" % oObj.class unless oObj.is_a?(Lorj::Data)
-            if oObj.type? == :list
-               Lorj::rhSet(@hParams, nil, :query, oObj.object_type?)
-            else
-               sObjectType = oObj.object_type?
-               @hParams[sObjectType] = nil
-            end
-         end
-         oObj.unregister unless oObj.nil?
-      end
-
-      # Merge 2 ObjectData.
-      #
-      # * *Args*    :
-      #   - +hHash+ : Hash of Lorj::Data. But it is possible to have different object type (not Lorj::Data)
-      # * *Returns* :
-      #   hash merged
-      # * *Raises* :
-      #   nothing
-      def << (hHash)
-         @hParams.merge!(hHash) unless hHash.nil?
-      end
-
-      # check Lorj::Data attributes or object exists. Or check key/value pair existence.
-      #
-      # * *Args*    :
-      #   - +hHash+ : Hash of Lorj::Data. But it is possible to have different object type (not Lorj::Data)
-      # * *Returns* :
-      #   true/false
-      # * *Raises* :
-      #   PrcError
-      def exist?(*key)
-         raise Lorj::PrcError.new, "ObjectData: key is not list of values (string/symbol or array)" if not [Array, String, Symbol].include?(key.class)
-
-         key = [key] if key.is_a?(Symbol) or key.is_a?(String)
-
-         key = key.flatten
-
-         oObject = Lorj::rhGet(@hParams, key[0])
-         return false if oObject.nil?
-
-         if oObject.is_a?(Lorj::Data)
-            # Return true if ObjectData Element is found when asked.
-            return true if key[1] == :ObjectData and oObject.type?(key[0]) == :object
-
-            # Return true if attritutes or controller object attributes found when asked.
-            return oObject.exist?(key[2..-1]) if key[1] == :attrs
-            return oObject.exist?(key[1..-1]) if key.length > 1
-            true
-         else
-            # By default true if found key hierarchy
-            (Lorj::rhExist?(@hParams, key) == key.length)
-         end
-      end
-
-      # Determine the type of object identified by a key. Lorj::Data attributes or object exists. Or check key/value pair existence.
-      #
-      # * *Args*    :
-      #   - +key+ : Key to check in ObjectData list.
-      # * *Returns* :
-      #   - nil if not found
-      #   - :data if the key value is simply a data
-      #   - :DataObject if the key value is a Lorj::Data
-      # * *Raises* :
-      #   PrcError
-
-      def type?(key)
-         return nil if Lorj::rhExist?(@hParams, key) != 1
-         :data
-         :DataObject if @hParams[key].type?() == :object
-      end
-
-      def cObj(*key)
-         Lorj::rhGet(@hParams, key, :object) if Lorj::rhExist?(@hParams, key, :object) == 2
-      end
-
-   end
-
+    end
+  end
 end