lorj 1.0.10 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66366295d6d2bd7fe5249ae3a23204fbf6feb041
-  data.tar.gz: 5f82817cfe94a3663ff15a0b2084da299fde4a43
+  metadata.gz: 4650a17061896bba5bafad8e12d15be96a37a532
+  data.tar.gz: 9ed6bb8936335cc1fa1c1236e95ef1c17a56e7e3
 SHA512:
-  metadata.gz: d3bc6abf89ad95748426300653103cf351ffcbc49ae1c319e6a77118444ccc819e88c8869cba6dac1a8f43ebd1e1e1720c855477a7ed8808b59d31b356ec2dc4
-  data.tar.gz: 8b0d0a9af74d981cb61a0f2330b697edffee5a0451071ba4ef4dc62a04184f91ca5c999b77de4993291c46a10b64b40e1b7be3485f11e2d2a86ea81142607078
+  metadata.gz: b9842cbc6ccf9d6068a76a0b82948a1c6196e10f5d46d9a40d12166961d2a328e5514a95e761387ef6a634783e851386cfcd0f48de4c4c4eba35c1d6bf9c56f1
+  data.tar.gz: f499cab40cd49a2494ff67e59a38704e4a193acff174b1df7dacf547f9ba13bce7c6796e344c63f00f01c043f4d54a70a9da51ec0326cb90c96686187b7a5adc

data/.rubocop.yml

@@ -33,14 +33,20 @@ Style/HashSyntax:
 
 # lets start with 40, but 10 is way to small..
 Metrics/MethodLength:
-  Max: 40
+  Max: 50
 # If Method length is increased, class length need to be extended as well.
 Metrics/ClassLength:
   Max: 150
 
 # allow arguments to be longer than 15
 Metrics/AbcSize:
-  Max: 40
+  Max: 50
+# Perceived Complexity
+Metrics/PerceivedComplexity:
+  Max: 9
+Metrics/CyclomaticComplexity:
+  Max: 8
+
 # forj-docker binary name gets an exception
 Style/FileName:
   Exclude: ['bin/forj-docker', 'lib/**/forj-docker.rb']

data/lib/core/core.rb

@@ -30,7 +30,7 @@ module Lorj
   # 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.
+  # It gives 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.
@@ -46,19 +46,29 @@ module Lorj
   # 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.
+  # Here an example of creating a CloudServer, using Lorj_cloud module
+  # See http://github.com/forj-oss/lorj-cloud
   #
-  #   oCloud = Lorj::CloudCore.new(oConfig, 'myhpcloud')
-  #   oConfig.set(:server_name,'myservername')
-  #   oCloud.create(:server)
+  #   require 'lorj_cloud'
   #
-  # Another basic example (See example directory)
+  #   process = { :process_module => 'cloud',
+  #               :controller_name => 'openstack' }
+  #   cloud = Lorj::Core.new(nil, [process])
+  #   cloud.setup(:server) # Ask end user about required data
+  #   cloud.create(:server, :server_name => 'myservername')
   #
-  #   oConfig = Lorj::Account.new()
-  #   oPrc = Lorj::Core.new(oConfig, 'mySqlAccount')
-  #   oCloud.create(:student, { :student_name => "Robert Redford"})
+  # Another basic example.
+  #
+  #   require 'lorj'
+  #
+  #   process = { :process_name    => 'myprocess',
+  #               :process_path    => '<myprocess_path>',
+  #               :controller_name => :mock }
+  #
+  #   core = Lorj::Core.new(nil, [process])
+  #   core.create(:myobject, :parameter1 => "value")
+  #
+  # You can learn on lorj by example, see examples/
   #
   # 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.
@@ -71,8 +81,8 @@ module Lorj
     # 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.
+    #   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:
     #
@@ -83,9 +93,9 @@ module Lorj
     #      config[key] = value
     #
     # - exist?(*key)                       : function which return false if not
-    #                                        found, or any other value if found.
+    #   found, or any other value if found.
     #   Ex: From processes, you can get a data (runtime/account/config.yaml or
-    #       defaults.yaml) with:
+    #   defaults.yaml) with:
     #
     #      config.get(key)
     #

data/lib/core/core_internal.rb

@@ -222,6 +222,8 @@ module Lorj
     #         This path must contains at least 'process' subdir. And if needed
     #         a 'controllers' path
     #       - :process_name   : Name of the local process
+    #       - :defaults       : Define the defaults data setting for the process
+    #       - :data           : Define process data definition.
     #
     #       Optionnally, you can set a controller name to use with the process.
     #       - :controller_name: Name of the controller to use.
@@ -230,13 +232,13 @@ module Lorj
     # * *Returns* :
     #   - model : Application model loaded.
     def init_processes(model, processes)
-      processes.each do |a_process|
+      processes.each_index do |index|
         my_process = {}
-
+        a_process = processes[index]
         if a_process.key?(:process_module)
-          my_process = _process_module_to_load(my_process, a_process)
+          my_process = _process_module_to_load(index, my_process, a_process)
         else
-          my_process = _process_local_to_load(my_process, a_process)
+          my_process = _process_local_to_load(index, my_process, a_process)
         end
 
         next if my_process.nil?
@@ -248,7 +250,10 @@ module Lorj
 
       model
     end
+  end
 
+  # Define internal private functions for controllers
+  class Core
     # high level function to load process
     def _process_load(model, my_process)
       if load_process(model, my_process[:process_path])
@@ -263,7 +268,7 @@ module Lorj
     end
 
     # function prepare of loading a local process
-    def _process_local_to_load(my_process, a_process)
+    def _process_local_to_load(index, my_process, a_process)
       my_process[:process_path] = a_process[:process_path]
 
       if a_process[:process_name].nil?
@@ -277,11 +282,37 @@ module Lorj
       else
         my_process[:controller_name] = a_process[:controller_name]
       end
+
+      defaults_file = a_process[:defaults]
+      if defaults_file.nil?
+        path = a_process[:process_path]
+        path['.rb'] = ''
+        defaults_file = File.join(path, 'defaults.yaml')
+      end
+
+      _process_load_data(config, index,
+                         a_process[:process_name], defaults_file,
+                         PRC::SectionConfig)
+
+      data_file = a_process[:data]
+      if defaults_file.nil?
+        path = a_process[:process_path]
+        path['.rb'] = ''
+        data_file = File.join(path, 'data.yaml')
+      end
+
+      _process_load_data(Lorj.data, index,
+                         a_process[:process_name], data_file)
+
+      # TODO: Implement Object definition as a config layer.
+      # _process_load_definition(definition, index, a_process[:process_name],
+      #                          a_process[:definition])
+
       my_process
     end
 
     # Function prepare of loading a module process.
-    def _process_module_to_load(my_process, a_process)
+    def _process_module_to_load(index, my_process, a_process)
       name = a_process[:process_module]
 
       if name.nil?
@@ -309,9 +340,54 @@ module Lorj
       _process_module_set_ctr(my_process, module_process.controllers,
                               a_process[:controller_name])
 
+      _process_load_data(config, index, name, module_process.defaults_file,
+                         PRC::SectionConfig)
+
+      _process_load_data(Lorj.data, index, name, module_process.data_file)
+
+      # TODO: Implement Object definition as a config layer.
+      # _process_load_definition(definition, index, name,
+      #                          module_process.definition)
+
       my_process
     end
 
+    # Load data definition in process data layers
+    def _process_load_data(config, index, name, file,
+                           config_class = PRC::BaseConfig)
+      return unless config.layer_index(name).nil?
+
+      return if file.nil?
+
+      layer = PRC::CoreConfig.define_layer(:name => name,
+                                           :config => config_class.new,
+                                           :load => true,
+                                           :set => false)
+      unless File.exist?(file)
+        PrcLib.warning("Process '%s', data file '%s' doesn't exist."\
+                       ' Not loaded.', name, file)
+        return
+      end
+
+      begin
+        unless layer[:config].load(file)
+          PrcLib.warning("Process '%s', data file '%s' was not loaded.",
+                         name, file)
+        end
+      rescue => e
+        PrcLib.error("Process '%s', unable to load data file '%s'. %s",
+                     name, file, e.message)
+      end
+
+      config.layer_add(layer.merge(:index => (config.layers.length - index)))
+    end
+
+    # Load process definition in process layers
+    # Function currently not developped.
+    #
+    # def _process_load_definition(a_process)
+    # end
+
     def _process_module_set_ctr(my_process, controllers, controller_name)
       return if controller_name.nil?
 

data/lib/core/core_object_params.rb

@@ -205,10 +205,6 @@ module Lorj
       _get_object_params(object_type, sEventType, fname, true)
     end
 
-    # TODO: Fix the Complexity
-    # rubocop: disable Metrics/CyclomaticComplexity
-    # rubocop: disable Metrics/PerceivedComplexity
-
     # internal runtime function for process call
     # Build a process/controller parameters object (ObjectData)
     #
@@ -241,12 +237,8 @@ module Lorj
         new_params = _obj_param_init(object_type, sEventType, as_controller)
       end
 
-      obj_params.each do |param_path, param_options|
-        if param_options.key?(:for)
-          next unless param_options[:for].include?(sEventType)
-        end
-
-        param_obj = KeyPath.new(param_path)
+      _object_params_event(object_type, sEventType).each do |param_obj|
+        param_options = obj_params[param_obj.fpath]
 
         value = _build_param(new_params, param_obj, param_options)
 
@@ -260,8 +252,47 @@ module Lorj
       new_params
     end
 
-    # rubocop: enable Metrics/CyclomaticComplexity
-    # rubocop: enable Metrics/PerceivedComplexity
+    # Function to provide a list of valid attributes for an event given.
+    #
+    # * *args* :
+    #   - +object_type+: object_type
+    #   - +event_type+ : Can be create_e, delete_e, query_e, get_e
+    #   - +param_type+ : Can be nil (default), :data or :CloudObject
+    #
+    # * *return*:
+    #   - params_obj : List of valid attributes (KeyPath type) for
+    #     the event given.
+    def _object_params_event(object_type, sEventType, param_type = nil)
+      obj_params = PrcLib.model.meta_obj.rh_get(object_type, :params, :keys)
+
+      attrs = []
+      obj_params.each do |param_path, param_options|
+        next unless _param_event?(param_options, sEventType)
+
+        next if param_type && param_type != param_options[:type]
+
+        attrs << KeyPath.new(param_path)
+      end
+      attrs
+    end
+
+    # Internal runtime function checking if the attribute is valid with event
+    # query
+    #
+    # * *args* :
+    #   - +param_options+: Parameter options to use.
+    #   - +param_path+   : Parameter path to check event
+    #   - +event_type+   : Can be create_e, delete_e, query_e, get_e
+    #
+    # * *return*:
+    #   - true if the attribute name is valid for this event.
+    #   - false otherwise.
+    def _param_event?(param_options, sEventType)
+      if param_options.key?(:for)
+        return false unless param_options[:for].include?(sEventType)
+      end
+      true
+    end
 
     # Internal runtime function for process call
     #

data/lib/core/core_process_setup.rb

@@ -129,12 +129,10 @@ module Lorj
         PrcLib.runtime_fail "Setup: '%s' not a valid object type."
       end
 
-      setup_steps = _setup_load
-
       Lorj.debug(2, "Setup is identifying account data to ask for '%s'",
                  sObjectType)
       # Loop in dependencies to get list of data object to setup
-      _setup_identify(sObjectType, setup_steps)
+      setup_steps = _setup_identify(sObjectType, _setup_load)
 
       Lorj.debug(2, 'Setup check if needs to add unrelated data in the process')
       _setup_check_additional(setup_steps)
@@ -152,39 +150,29 @@ module Lorj
     # Internal function to insert the data after several data to ask.
     #
     # * *Args* :
-    #   - data_to_check : setup data structure to update.
+    #   - step          : step structure to update.
     #   - data_to_add   : data to add
-    #   - step          : current step analyzed.
     #   - order_index   : last order index of the current step analyzed.
     #
     # * *Returns*:
     #
     # * *Raises* :
     #
-    def _setup_data_insert(setup_steps, data_to_add, step, order_index)
-      level_index = 0
-
-      _setup_data_after(data_to_add).each do |sAfterKey|
-        setup_steps.each_index do |iStepToCheck|
-          order_array = setup_steps[iStepToCheck][:order]
-
-          order_array.each_index do |iLevelToCheck|
-            data_to_ask = order_array[iLevelToCheck]
-            order_to_check = data_to_ask.index(sAfterKey)
-
-            next if order_to_check.nil?
-
-            step = iStepToCheck if iStepToCheck > step
-            level_index = iLevelToCheck if iLevelToCheck > level_index
-            order_index = order_to_check + 1 if order_to_check + 1 > order_index
-            break
-          end
-        end
+    def _setup_data_insert(step, data_to_add)
+      order_index = _setup_data_where?(step[:order], data_to_add)
+
+      if order_index.nil?
+        level_index = step[:order].keys.max
+        step[:order][level_index] << data_to_add
+        Lorj.debug(3, "%s/L%s/O%s: '%s' added in setup list at position.",
+                   step[:name], level_index,
+                   step[:order][level_index].length - 1,
+                   data_to_add)
+        return
       end
-
-      setup_steps[step][:order][level_index].insert(order_index, data_to_add)
-      Lorj.debug(3, "S%s/L%s/O%s: '%s' added in setup list at position.",
-                 step, level_index, order_index, data_to_add)
+      step[:order][order_index[0]].insert(order_index[1], data_to_add)
+      Lorj.debug(3, "%s/L%s/O%s: '%s' added in setup list at position.",
+                 step[:name], order_index[0], order_index[1], data_to_add)
     end
 
     # Internal function to get :after list of data to ask.
@@ -198,13 +186,51 @@ module Lorj
     #
     # * *Raises* :
     #
-    def _setup_data_after(data_to_check)
+    def _setup_data_where?(order, data_to_check)
+      res = _setup_data_position?(order, data_to_check)
+
+      return nil if res.nil?
+
+      after_index, before_index, after, before = res
+
+      if after_index.nil? || before_index.nil?
+        return before_index if after_index.nil?
+        return after_index
+      end
+
+      if after_index[0] > before_index[0] ||
+         (after_index[0] == before_index[0] && after_index[1] > before_index[1])
+        PrcLib.warning("Unable to insert '%s' attribute before '%s' (pos %s)"\
+                       " and after '%s' (pos %s). "\
+                       "'%s' will be added at the end.",
+                       data_to_check, before, before_index, after, after_index,
+                       data_to_check)
+        return nil
+      end
+
+      after_index
+    end
+
+    def _setup_data_position?(order, data_to_check)
       meta = _get_meta_data(data_to_check)
-      return [] unless meta.rh_exist?(:after)
+      return nil if meta.nil?
+      return nil unless meta.rh_exist?(:after) || meta.rh_exist?(:before)
+
+      after = meta.rh_get(:after)
+      before = meta.rh_get(:before)
+      after_index = nil
+      before_index = nil
+
+      order.each do |k, attrs|
+        attrs.each do |attr_name|
+          after_index = [k, attrs.index(attr_name) + 1] if after == attr_name
+          before_index = [k, attrs.index(attr_name)] if before == attr_name
+        end
+      end
 
-      datas_after = meta[:after]
-      datas_after = [datas_after] unless datas_after.is_a?(Array)
-      datas_after
+      return nil if after_index.nil? && before_index.nil?
+
+      [after_index, before_index, after, before]
     end
 
     # check if a config data is already listed in the setup list at a specific
@@ -217,149 +243,11 @@ module Lorj
     # * *returns* :
     #   - true if found. false otherwise.
     def _setup_attr_already_added?(order_array, data_to_check)
-      order_array.each_index do |order_index|
+      order_array.each_key do |order_index|
         attributes = order_array[order_index]
         return true unless attributes.index(data_to_check).nil?
       end
       false
     end
-
-    # Add the attribute parameter to setup list
-    # at the right position, determined by it dependencies.
-    #
-    # The attribute can be added only if :account is true. Data set in
-    # the application defaults.yaml:
-    # :sections/<Section>/<Attribute>/:account: true
-    #
-    # Attributes dependency is first loaded by the lorj object model
-    # Each attributes can add more dependency thanks to the application
-    # defaults.yaml:
-    # :sections/<Section>/<Attribute>/:depends_on (Array of attributes)
-    #
-    # The attribute step can be set from defaults.yaml as well:
-    # :sections/<Section>/<Attribute>/:ask_step (FixNum)
-    #
-    # The attribute can be asked at a determined index, set in
-    # the application defaults.yaml:
-    # :sections/<Section>/<Attribute>/:ask_sort: (FixNum)
-    #
-    # parameters :
-    # - +setup_steps+ : setup steps
-    # - +attr_name+   : Attribute to add
-    def _setup_obj_param_is_data(setup_steps, inspected_objects, attr_name)
-      if inspected_objects.include?(attr_name)
-        Lorj.debug(2, "#{attr_name} is already asked. Ignored.")
-        return false
-      end
-
-      meta = _get_meta_data(attr_name)
-      return false unless meta.is_a?(Hash)
-
-      ask_step = 0
-      ask_step = meta[:ask_step] if meta[:ask_step].is_a?(Fixnum)
-
-      Lorj.debug(3, "#{attr_name} is part of setup step #{ask_step}")
-      order_array = setup_steps[ask_step][:order]
-
-      unless meta[:account].is_a?(TrueClass)
-        Lorj.debug(2, "'%s' won't be asked during setup."\
-                   ' :account = true not set.', attr_name)
-        return false
-      end
-
-      level_index = _setup_level_index(order_array, attr_name,
-                                       meta[:depends_on])
-
-      return true if order_array[level_index].include?(attr_name)
-
-      level = _setup_attr_add(order_array[level_index], attr_name, meta,
-                              level_index)
-      Lorj.debug(3, "S%s/L%s/%s: '%s' added in setup list. ",
-                 ask_step, level, level_index, attr_name)
-
-      true
-    end
-
-    # Function to identify level index for an attribute.
-    #
-    # parameters:
-    # - +order_array+ : array of levels of attributes ordered.
-    # - +attr_name+   : attribute name
-    # - +depends_on+  : Dependency Array.
-    #
-    # return:
-    # - level_index to use.
-    def _setup_level_index(order_array, attr_name, depends_on)
-      if !depends_on.is_a?(Array)
-        PrcLib.warning("'%s' depends_on definition have to be"\
-                       ' an array.',
-                       attr_name) unless depends_on.nil?
-        0
-      else
-        _setup_find_dep_level(order_array, depends_on)
-      end
-    end
-
-    # Function to add an attribute to the level layer of the setup array .
-    #
-    # parameters:
-    # - +level_array+ : array of attributes ordered.
-    # - +attr_name+   : attribute name
-    # - +order_index+ : order index where to insert the attribute.
-    #
-    def _setup_attr_add(level_array, attr_name, meta, level_index)
-      if meta[:ask_sort].is_a?(Fixnum)
-        order_index = meta[:ask_sort]
-        _setup_attr_add_at(level_array, attr_name, order_index)
-        Lorj.debug(3, "S%s/L%s/O%s: '%s' added in setup list. ",
-                   meta[:ask_step], level_index, order_index, attr_name)
-        "O#{level_index}"
-      else
-        level_array << attr_name
-        Lorj.debug(3, "S%s/L%s/Last: '%s' added in setup list.",
-                   meta[:ask_step], level_index, attr_name)
-        'Last'
-      end
-    end
-
-    # Function to insert an attribute at a specific order.
-    # It will shift other attributes if needed.
-    #
-    # parameters:
-    # - +level_array+ : array of attributes ordered.
-    # - +attr_name+   : attribute name
-    # - +order_index+ : order index where to insert the attribute.
-    #
-    def _setup_attr_add_at(level_array, attr_name, order_index)
-      if level_array[order_index].nil?
-        level_array[order_index] = attr_name
-      else
-        level_array.insert(order_index, attr_name)
-      end
-    end
-
-    # Search for the lowest step to ask an attribute, thanks to dependencies.
-    #
-    # parameters:
-    # - +order_array+ : Array of attributes, at 2 dimensions [step then order]
-    # - +attr_dep+    : Array of attributes/objects needed before this
-    #                   attribute.
-    #
-    # returns:
-    # - the lowest step index where the attribute can be added.
-    def _setup_find_dep_level(order_array, attr_dep)
-      level_index = 0
-
-      attr_dep.each do |depend_key|
-        order_array.each_index do |iCurLevel|
-          if order_array[iCurLevel].include?(depend_key)
-            level_index = [level_index, iCurLevel + 1].max
-          end
-        end
-        order_array[level_index] = [] if order_array[level_index].nil?
-      end
-
-      level_index
-    end
   end
 end

data/lib/core/core_setup_ask.rb

@@ -57,6 +57,8 @@ module Lorj
         section = _get_account_section(data)
         # We set the value only if there is a value entered by the user.
         unless section.nil? || value.nil?
+          Lorj.debug(3, "'%s'/'%s': Setting value to '%s'",
+                     section, data, value)
           @config.set(data, value, :name => 'account', :section => section)
         end
 
@@ -130,7 +132,7 @@ module Lorj
     #  - +desc+        : Data description
     #  - +options+     : Used when user have to enter a string instead of
     #                    selecting from a list.
-    #   - +:default_value+ : predfined default value.
+    #    - +:default_value+ : predefined default value.
     #
     #     if data model defines :default_value. => choose it
     #     In this last case, the :default_value is interpreted by ERB.
@@ -159,12 +161,14 @@ module Lorj
       default = result[:default_value] unless result[:default_value].nil?
 
       begin
+        Lorj.debug(3, "'%s': ERB on default value '%s'", data, default)
         default = erb(default) unless default.nil?
       rescue => e
         PrcLib.warning("ERB error with :%s/:default_value '%s'.\n%s",
                        data, result[:default_value], e.message)
       else
         default = nil if default == ''
+        Lorj.debug(3, "'%s': default value '%s'", data, default)
         options[:default_value] = default
       end
 
@@ -207,6 +211,11 @@ module Lorj
     #
     def _setup_choose_data_from_list(data, desc, list, options)
       default = @config.get(data, options[:default_value])
+      Lorj.debug(3, "'%s': Getting value from config - '%s'(from '%s' - "\
+                    "sections '%s')"\
+                    " (default is '%s')",
+                 data, default, @config.where?(data), Lorj.data.sections(data),
+                 options[:default_value])
 
       say_msg = format("Select '%s' from the list:", desc)
       say_msg += format(' |%s|', default) unless default.nil?
@@ -259,18 +268,24 @@ module Lorj
       if default.nil? && !options[:default_value].nil?
         begin
           default = erb(options[:default_value])
+          Lorj.debug(3, "'%s': Running ERB for default_value '%s' = '%s'",
+                     data, options[:default_value], default)
         rescue => e
           PrcLib.warning("ERB error with :%s/:default_value '%s'.\n%s",
                          data, options[:default_value], e.message)
         end
       end
-      default = @config.get(data, default)
+      ask_default = @config.get(data, default)
+      Lorj.debug(3, "'%s': Getting value from config - '%s'(from '%s' - "\
+                    "sections '%s') (default is '%s')",
+                 data, ask_default, @config.where?(data),
+                 Lorj.data.sections(data), default)
 
       # validate_proc = options[:validate_function]
       proc_ask = options[:ask_function]
 
       if proc_ask.nil?
-        value = _ask(desc, default, valid_regex, is_encrypted, is_required)
+        value = _ask(desc, ask_default, valid_regex, is_encrypted, is_required)
       else
         value = @process.method(proc_ask)
       end