lorj 1.0.10 → 1.0.11

data/lib/core/core_setup_init.rb

@@ -26,8 +26,8 @@ require 'erb'
 # this task to make it to work.
 module Lorj
   # Adding process core functions.
-  class BaseDefinition
-    # Load /:setup/:ask_step section of the defaults.yaml
+  class BaseDefinition # rubocop: disable ClassLength
+    # Load /:setup/:ask_step section of the data.yaml
     #
     # See lib/core/core_model.rb
     #
@@ -37,16 +37,63 @@ module Lorj
     # * *Raises* :
     #
     def _setup_load
+      setup_steps = {}
+
+      steps = Lorj.data.setup_data(:steps)
+      return setup_steps if steps.nil?
+
+      steps.each do |name, value|
+        setup_steps[name] = _setup_load_init(value)
+      end
+
+      ask_steps = Lorj.data.setup_data(:ask_step)
+      return setup_steps if ask_steps.nil?
+
+      ask_steps.each do |value|
+        name = value[:name]
+        name = ask_steps.index(value).to_s if name.nil?
+        if setup_steps.key?(name)
+          setup_steps[name].rh_merge(_setup_load_init(value))
+          next
+        end
+        setup_steps[name] = _setup_load_init(value)
+      end
+
+      setup_steps
+    end
+
+    def _setup_load_init(value)
+      value = {} if value.nil?
+
+      {
+        :desc => value[:desc],
+        :explanation => value[:explanation],
+        :pre_step_handler => value[:pre_step_function],
+        :order => [[]], # attributes in array of level/order
+        :post_step_handler => value[:post_step_function]
+      }
+    end
+
+    def _setup_step_definition
+      setup_steps = {}
+      steps = Lorj.data.setup_data(:steps)
+      return setup_steps if steps.nil?
+
+      steps.each do |name, value|
+        setup_steps[name] = value
+      end
+
       ask_steps = Lorj.data.setup_data(:ask_step)
-      setup_steps = []
+      return setup_steps if ask_steps.nil?
+
       ask_steps.each do |value|
-        setup_steps << {
-          :desc => value[:desc],
-          :explanation => value[:explanation],
-          :pre_step_handler => value[:pre_step_function],
-          :order => [[]], # attributes in array of level/order
-          :post_step_handler => value[:post_step_function]
-        }
+        name = value[:name]
+        name = ask_steps.index(value).to_s if name.nil?
+        if setup_steps.key?(name)
+          setup_steps[name].rh_merge(value)
+          next
+        end
+        setup_steps[name] = value
       end
       setup_steps
     end
@@ -63,83 +110,907 @@ module Lorj
     # * *Raises* :
     #
     def _setup_check_additional(setup_steps)
-      setup_steps.each_index do |step|
-        value = Lorj.data.setup_data(:ask_step)[step]
-        next unless value.rh_exist?(:add)
+      setup_steps.each do |step|
+        step_name = step[:name]
+        value = _setup_step_definition
+        next unless value.is_a?(Hash) && value.rh_exist?(step_name, :add)
 
-        datas_to_add = value.rh_get(:add)
+        datas_to_add = value.rh_get(step_name, :add)
         datas_to_add.each do |data_to_add|
-          order_array = setup_steps[step][:order]
+          order_array = step[:order]
           next if _setup_attr_already_added?(order_array, data_to_add)
 
-          _setup_data_insert(setup_steps, data_to_add, step, order_array.length)
+          _setup_data_insert(step, data_to_add)
         end
       end
     end
 
-    # Loop on object dependencies to determine the list of attributes to setup.
+    # Function to build a step/order structure of Attributes.
+    # step/order is an array of array.
+    # the first array represents the steps
+    # the second array represents the list of attributes in a specific order.
+    #
+    # This structure is used by setup to ask the list of attributes in a
+    # specific order.
+    #
+    # It loops on object dependencies, then data definition to determine the
+    # list of attributes and their required order.
+    #
+    # A new step is created when an attribute, during setup time requires
+    # to query an object, which may requires some additional attributes,
+    # considered as dependent attributes.
+    # The previous step must contains at least the dependent attributes.
     #
+    # Process data definition can influence those detected steps, by assigning
+    # an :ask_step to the attribute.
+    # Then the default attribute step may be splitted to more steps.
+    #
+    # You cannot set an attribute step lower then the detected step.
+    # Process data definition can influence the attributes order, by assigning
+    # an :ask_order to the attribute.
+    #
+    # :setup section of the process data definition (data.yaml) can set the step
+    # description or add some extra attributes (not detected by default)
     #
     # * *Args* :
+    #   - sObjectType : Symbol/String. Object type to analyze for list of
+    #     attributes to setup
     #   - setup_steps : Hash. setup data structure to update.
     #                   It will update setup_steps:/:order 2 dimensions array
     #
     # * *Returns*:
-    #   - Nothing. But setup_steps is updated.
+    #   - setup_steps: Hash updated
     #
     # * *Raises* :
     #
     def _setup_identify(sObjectType, setup_steps)
-      objs_to_inspect = [sObjectType]
-      inspected_objects = []
-
-      while objs_to_inspect.length > 0
-        # Identify data to ask
-        # A data to ask is a data needs from an object type
-        # which is declared in section of defaults.yaml
-        # and is declared :account to true (in defaults.yaml or in process
-        # declaration - define_data)
-
-        object_type = objs_to_inspect.pop
-
-        Lorj.debug(1, "Checking '%s'", object_type)
-        attributes = PrcLib.model.meta_obj.rh_get(object_type,
-                                                  :params, :keys)
-        if attributes.nil?
-          Lorj.debug(1, "Warning! Object '%s' has no data/object needs. Check"\
-                        ' the process', object_type)
-          next
-        end
-        attributes.each do |attr_path, attr_params|
-          attr_name = KeyPath.new(attr_path).key
-          _setup_identify_obj_params(setup_steps,
-                                     inspected_objects, objs_to_inspect,
-                                     attr_name, attr_params)
-        end
+      # There is 3 sources of data used by setup to build the list of data to
+      # setup:
+      # - Lorj.data (Lorj::MetaConfig): Process data definition.
+      # - config (Lorj::Account)      : Configuration files/runtime data.
+      # - PrcLib.model.meta_obj(Hash) : Object definition / mapping
+
+      dependencies = { :objects => {}, :attributes => {} }
+      _setup_identify_dep_init(dependencies, sObjectType)
+
+      # Build list of attributes which will be needed for an object and
+      # its dependencies
+
+      Lorj.debug(2, '- Checking objects dependencies -')
+      _setup_identify_deps(dependencies, sObjectType)
+
+      # Build list of additional attributes and build
+      # attribute dependencies thanks to attribute queries.
+      Lorj.debug(2, '- Checking attributes dependencies -')
+      orders = _setup_build_steps_from(dependencies)
+
+      # Reorganize each required steps thanks to :ask_order
+      Lorj.debug(2, '- Re-organizing attributes steps/order -')
+      attrs = _setup_reorganize_steps_order(dependencies[:attributes], orders)
+
+      # Apply additionnal steps as described by Lorj.data
+      Lorj.debug(2, '- Add extra steps -')
+      _setup_reorganize_steps(attrs, orders, setup_steps)
+    end
+
+    # Internal setup function to parse objects/attributes dependency list
+    # and build objects list and required attributes list.
+    def _setup_identify_deps(dependencies, object_type, path = [])
+      model_object = dependencies.rh_get(:objects, object_type)
+      objects_list = PrcLib.model.meta_obj.rh_get(object_type, :params, :keys)
+      if objects_list.nil?
+        PrcLib.warning("'%s' as object type is not valid. Not declared.")
+        return [[], [], []]
       end
+
+      objects = []
+      attrs = []
+      deps_attrs = []
+      deps_objects = []
+      new_path = path + [object_type]
+
+      objects_list.each do |attr_path, attr_params|
+        a, d_a, o, d_o = _setup_id_each(dependencies, model_object, new_path,
+                                        attr_path, attr_params)
+        attrs += a
+        deps_attrs += d_a
+        objects += o
+        deps_objects += d_o
+      end
+      attrs.uniq!
+      deps_attrs.uniq!
+      objects.uniq!
+      deps_objects.uniq!
+
+      _sid_show_debug(3, format("'%s' has ", object_type) + '%s',
+                      attrs, objects)
+      _sid_show_debug(4, format("'%s' has ", object_type) + 'also indirect %s',
+                      deps_attrs, deps_objects)
+
+      [(objects + deps_objects).uniq, attrs, deps_attrs]
     end
 
-    # Internal setup function to identify data to ask
-    # Navigate through objects dependencies to determine the need.
-    def _setup_identify_obj_params(setup_steps,
-                                   inspected_objects, objs_to_inspect,
-                                   attr_name, attr_params)
+    def _setup_id_each(dependencies, model_object, new_path,
+                       attr_path, attr_params)
+      objects = []
+      attrs = []
+      deps_attrs = []
+      deps_objects = []
 
+      attr_name = KeyPath.new(attr_path).key_tree
       attr_type = attr_params[:type]
 
       case attr_type
       when :data
-        return unless _setup_obj_param_is_data(setup_steps,
-                                               inspected_objects, attr_name)
-        inspected_objects << attr_name
-        return
+        attr_to_add = _setup_id_init_data_deps(dependencies, attr_name)
+        if attr_to_add
+          model_object[:attrs] << attr_to_add
+          attrs << attr_to_add
+        end
       when :CloudObject
-        return if objs_to_inspect.include?(attr_name) ||
-                  inspected_objects.include?(attr_name)
-        # New object to inspect
-        objs_to_inspect << attr_name
+        if _setup_identify_dep_init(dependencies, attr_name, new_path)
+          found_obj,
+            found_attrs,
+            found_deps_attrs = _setup_identify_deps(dependencies,
+                                                    attr_name, new_path)
+        else
+          found_obj = dependencies.rh_get(:objects, attr_name, :objects)
+          found_attrs = dependencies.rh_get(:objects, attr_name, :attrs)
+          found_deps_attrs = []
+        end
+        deps_objects = (deps_objects + found_obj).uniq
+        deps_attrs = (deps_attrs + found_attrs + found_deps_attrs).uniq
+        model_object[:objects] << attr_name
+        objects << attr_name
+      end
+      [attrs, deps_attrs, objects, deps_objects]
+    end
+
+    def _setup_id_init_data_deps(dependencies, attr_name)
+      return if dependencies[:attributes].key?(attr_name)
+
+      dependencies.rh_set({}, :attributes, attr_name)
+      attr_name
+    end
+
+    # Internal setup function to display debug info related to
+    # _setup_identify_deps
+    def _sid_show_debug(level, str, attrs, objects)
+      data = []
+      data << format("'%s' attributes", attrs.join(', ')) if attrs.length > 0
+
+      data << format("'%s' objects", objects.join(', ')) if objects.length > 0
+
+      Lorj.debug(level, str, data.join(' and ')) if data.length > 0
+    end
+
+    # Internal setup function to build Attribute dependency array
+    # based on :depends_on
+    #
+    # def _setup_identify_attr_depends_on(_attr_name)
+    #   attrs_dep = []
+    #   num = 0
+
+    #   dependencies[:attributes].each do |attr_name, dep|
+    #     next unless dep.nil?
+    #     attr_def = Lorj.data.auto_section_data(attr_name)
+
+    #     dependency = []
+    #     if attr_def && attr_def[:depends_on].is_a?(Array)
+    #       dependency = attr_def[:depends_on].clone
+    #     end
+    #     attrs_dep[num] = dependency
+    #     num += 1
+    #   end
+
+    #   attrs_dep
+    # end
+
+    # Internal setup function to Reorganize attributes order thanks following
+    # data definition:
+    #
+    # - :sections/<Section>/<Attribute>/:ask_sort: (FixNum)
+    #   Defines the list of attributes that needs to be setup before.
+    #
+    # This function will first of all determine the order thanks
+    # to :ask_sort in the current step group.
+    def _setup_reorganize_steps_order(attrs, attr_groups)
+      attr_groups.collect do |attr_group|
+        index = attr_groups.index(attr_group)
+        Lorj.debug(3, "Step '%s' analyzing re-organisation", index)
+        res = _setup_reorganize_so_sort(attr_group)
+        res = _setup_reorganize_so_befaft(res)
+
+        old = attr_group.map { |attr| attr.keys[0] }
+        new = res.map { |attr| attr.keys[0] }
+        Lorj.debug(3, "Step '%s' reorganized from '%s' to '%s'",
+                   index, old, new) unless old == new
+        attr_groups[index] = res
+      end
+
+      attrs_list = []
+      attrs.each do |k, v|
+        attrs_list << { k => v }
+      end
+      res = _setup_reorganize_so_sort(attrs_list)
+      res = _setup_reorganize_so_befaft(res)
+
+      old = attrs_list.map { |attr| attr.keys[0] }
+      new = res.map { |attr| attr.keys[0] }
+      Lorj.debug(3, "unordered reorganized from '%s' to '%s'",
+                 old, new) unless old == new
+      res
+    end
+
+    # Internal setup function to re-organize thanks to :before and :after.
+    def _setup_reorganize_so_befaft(attr_group)
+      attrs = attr_group.map { |a| a.keys[0] }
+
+      attrs.clone.each do |attr_name|
+        meta = _get_meta_data(attr_name)
+        next if meta.nil?
+        next unless meta.rh_exist?(:after) || meta.rh_exist?(:before)
+
+        if _setup_reorganize_so_befaft_move?(:after, meta, attrs, attr_name)
+          _setup_reorganize_so_befaft_move(:after, meta, attrs, attr_group,
+                                           attr_name)
+        end
+
+        next unless _setup_reorganize_so_befaft_move?(:before, meta, attrs,
+                                                      attr_name)
+
+        _setup_reorganize_so_befaft_move(:before, meta, attrs, attr_group,
+                                         attr_name)
+      end
+      attr_group
+    end
+
+    # return true if there is a need to move the element before/after
+    def _setup_reorganize_so_befaft_move?(where, meta, attrs, attr_name)
+      element = meta[where]
+      element = nil unless (attrs - [attr_name]).include?(element)
+
+      cur = attrs.index(attr_name)
+      return (element && cur < attrs.index(element)) if where == :after
+      (element && cur > attrs.index(element))
+    end
+
+    # Do the move
+    def _setup_reorganize_so_befaft_move(where, meta, attrs, attr_group,
+                                         attr_name)
+      old = attrs.index(attr_name)
+      ref = meta[where]
+      new = attrs.index(ref)
+
+      # Must be inserted after the attribute => + 1
+      new += 1 if where == :after
+
+      Lorj.debug(5, ":%s: Move '%s' %s '%s'"\
+                        " - pos '%s' => pos '%s'",
+                 where, attr_name, where, ref, old, new)
+
+      attrs.insert(new, attrs.delete(attr_name))
+      attr_group.insert(new, attr_group.delete(attr_group[old]))
+    end
+
+    # Internal setup function to re-organize thanks to :ask_sort
+    def _setup_reorganize_so_sort(attr_group)
+      attr_subgroups = []
+      attr_noorder = []
+
+      attr_group.each do |attr|
+        attr_def = attr[attr.keys[0]]
+        if attr_def[:ask_sort].is_a?(Fixnum)
+          Lorj.debug(4, "'%s' position requested is '%s'",
+                     attr.key(attr_def), attr_def[:ask_sort])
+          if attr_subgroups[attr_def[:ask_sort]].nil?
+            attr_subgroups[attr_def[:ask_sort]] = [attr]
+          else
+            attr_subgroups[attr_def[:ask_sort]] << attr
+          end
+        else
+          attr_noorder << attr
+        end
+      end
+
+      attr_subgroups.flatten!
+
+      attr_subgroups + attr_noorder
+    end
+
+    # Internal setup function to re-organize steps as described by
+    # :setup/:steps section and data property :step
+    #
+    def _setup_reorganize_steps(steps_unordered, steps, setup_steps)
+      steps << steps_unordered
+
+      # build the steps attributes
+      build_steps = [{ :order => {} }]
+      build_step = 0
+      step_name = nil
+      #  cur_step = build_steps[build_step]
+      Lorj.debug(3, "Building setup step position '%s'", build_step)
+
+      steps.each_index do |step_index|
+        steps[step_index].each do |attr|
+          attr_name = attr.keys[0]
+          attr_def = attr[attr_name]
+
+          unless attr_def[:setup]
+            Lorj.debug(2, "'%s' is ignored. configured with :account = '%s'",
+                       attr_name, attr_def[:setup])
+            next
+          end
+
+          step_name = _setup_ros_get_step_name(attr_def)
+
+          next if _setup_ros_same_step_name(build_steps[build_step],
+                                            step_index, step_name, attr_name)
+
+          build_step = _setup_ros_set_step(:build_steps => build_steps,
+                                           :build_step => build_step,
+                                           :setup_steps => setup_steps,
+                                           :step_index => step_index,
+                                           :step_name => step_name,
+                                           :attr_name => attr_name)
+
+          _setup_ros_add_attribute(build_steps[build_step][:order],
+                                   step_index, attr_name)
+        end
+      end
+
+      if build_steps.last[:name].nil?
+        _setup_ros_set_step(:build_steps => build_steps,
+                            :setup_steps => setup_steps,
+                            :step_index => steps.length - 1,
+                            :attr_name => :default)
+      end
+
+      build_steps
+    end
+
+    # Internal function to get the step name to use
+    def _setup_ros_get_step_name(attr_def)
+      return nil if attr_def[:ask_step].nil?
+
+      step_name = attr_def[:ask_step]
+      step_name = step_name.to_s if step_name.is_a?(Fixnum)
+      step_name
+    end
+
+    # Internal function checking if the step is already assigned
+    def _setup_ros_same_step_name(build_step, stepo_index, step_name, attr_name)
+      return false unless step_name.nil? || build_step[:name] == step_name
+
+      _setup_ros_add_attribute(build_step[:order], stepo_index, attr_name)
+      true
+    end
+
+    # Internal function to add an attribute to the step_order structure.
+    def _setup_ros_add_attribute(step_order, stepo_index, attr_name)
+      step_order[stepo_index] = [] if step_order[stepo_index].nil?
+      step_order[stepo_index] << attr_name
+    end
+
+    #  attr_steps.reject! { |group| group.length == 0 }
+
+    # Set the step data to the current order built.
+    #
+    # If the step has already been set, a warning is printed.
+    #
+    # * *returns*:
+    #   - +Return the
+    #
+    def _setup_ros_set_step(params)
+      build_steps = params[:build_steps]
+      build_step = params[:build_step]
+      step_index = params[:step_index]
+      step_name = params[:step_name]
+      attr_name = 'of latest step'
+      attr_name = params[:attr_name] unless params[:attr_name].nil?
+
+      setup_step = params[:setup_steps][step_name]
+      if setup_step.nil?
+        PrcLib.warning("Attribute '%s': Setup step '%s' is not defined.",
+                       attr_name, step_name)
+        return build_step
+      end
+
+      step_found = _setup_ros_find_buildstep(build_steps, step_index,
+                                             step_name)
+
+      return build_step if step_found.nil?
+
+      if step_found == build_steps.length
+        step = { :order => { step_index => [] } }
+        Lorj.debug(3, "Building setup step position '%s'", step_found)
+        build_steps << step
+      end
+
+      build_step = step_found
+      step = build_steps[build_step]
+
+      return build_step if step[:name] == step_name
+
+      step[:name] = step_name
+
+      step[:desc] = setup_step[:desc]
+      step[:explanation] = setup_step[:explanation]
+      step[:pre_step_handler] = setup_step[:pre_step_function]
+      step[:post_step_handler] = setup_step[:post_step_function]
+
+      Lorj.debug(3, "Requested by '%s' attribute, setup step position '%s'"\
+                    " is assigned to '%s'", attr_name,
+                 build_steps.length - 1, step_name)
+      build_step
+    end
+
+    # Internal Function searching in build_steps a step_name.
+    # If found, the index is kept.
+    #
+    # If found, it compares the index with the current step_index
+    # It will be considered valid if the step index has a
+    # step_index in :orders or if the step_index - 1 is the found
+    # in the last known step.
+    #
+    # If the step is not found, the index returned will be a new index
+    # to create in build_steps.
+    #
+    # * *args*:
+    #   - +build_steps+      : List of build_steps already identified.
+    #   - +step_order_index+ : current step order index to add an attribute to.
+    #   - +step_name+        : Step name to search.
+    #
+    # * *return*:
+    #   - +index+ : It returns a correct build_step to use.
+    #   - *nil*   : nil if there is no valid index to return.
+    #
+    def _setup_ros_find_buildstep(build_steps, step_order_index,
+                                    searched_step_name)
+      return 0 if step_order_index == 0
+
+      step_found = nil
+      last_step_order_found = nil
+
+      build_steps.each_index do |i|
+        step_found = i if build_steps[i][:name] == searched_step_name
+        if build_steps[i][:order].include?(step_order_index - 1)
+          last_step_order_found = i
+        end
+      end
+
+      return build_steps.length if step_found.nil?
+
+      if step_found
+        if build_steps[step_found][:order].include?(step_order_index)
+          return step_found
+        end
+
+        return step_found if step_found >= last_step_order_found
+      end
+
+      PrcLib.warning("Unable to set step '%s' at position %s. "\
+                     "This step is already at position '%s'. "\
+                     "Due to attribute dependencies, attribute '%' cannot be"\
+                     ' asked at that step. Please correct the process'\
+                     ' definition. ',
+                     step_name, build_steps.index(e),
+                     build_steps.length - 1, attr_name)
+      nil
+    end
+    # Internal setup function to complete the list of attributes
+    # and organize attributes by step as requested by attr dependencies
+    # It loops on a list of unanalyzed attributes to determine
+    # new objects/attributes
+    #
+    # The analyze is based on attributes having setup obj (and group of deps)
+    # required
+    #
+    # A new level is added:
+    # - when a new group of deps is found.
+    #   Then each attributes required decrease the level by 1.
+    # - when a group already exist, nothing is done
+    #
+    # In case of depends_on, the attribute level is set to 0
+    # and depends_on attributes level are decreased.
+    # each attributes parsed get a level 0 if requires a group is requires
+    # otherwise level is set to nil.
+    def _setup_build_steps_from(dependencies)
+      count = dependencies[:attributes].length
+      attrs_done = {}
+      level = 0
+      loop do
+        attrs = dependencies[:attributes].clone
+        attrs.each_key do |attr_name|
+          next if attrs_done.key?(attr_name)
+
+          element = _setup_bs_objs(attrs_done, dependencies, attr_name)
+
+          attrs_done[attr_name] = element
+          dependencies.rh_set(element, :attributes, attr_name)
+
+          if element.rh_exist?(:group, :level)
+            level = [level, element[:group][:level]].min
+          end
+
+          list_attrs = (element[:attrs] + element.rh_get(:group, :attrs)).uniq
+
+          next if list_attrs.length == 0
+          Lorj.debug(2, "setup: '%s' attribute dependency found '%s'",
+                     attr_name, list_attrs.join(', '))
+        end
+        break if dependencies[:attributes].length == count
+        count = dependencies[:attributes].length
+      end
+
+      # Thanks to attributes/group deps, set levels
+      attrs = dependencies[:attributes]
+      _setup_bs_levels(attrs, level)
+    end
+
+    # Uses attributes level detected to initialize the list of steps/orders.
+    def _setup_bs_levels(attrs, level)
+      steps = [[]]
+      pos = 0
+
+      loop do
+        attrs.clone.each do |k, v|
+          cur_level = v.rh_get(:group, :level)
+          next unless cur_level == level
+
+          attrs_to_add = v[:attrs] + v.rh_get(:group, :attrs).uniq
+          attrs.reject! do |attr, _|
+            res = attrs_to_add.include?(attr)
+            steps[pos] << { attr => attrs[attr] } if res
+            res
+          end
+
+          steps[pos + 1] = [] if steps[pos + 1].nil?
+
+          steps[pos + 1] << { k => attrs[k] }
+          attrs.reject! { |attr, _| attr == k }
+        end
+        level += 1
+        break if level == 0
+        pos += 1
+      end
+      steps
+    end
+
+    # Internal setup function to build the list of attribute deps
+    #
+    def _setup_bs_objs(attrs_done, dependencies, attr_name)
+      # Check if this attr requires an object query.
+      Lorj.debug(2, "-- Checking '%s' attribute --", attr_name)
+      data = Lorj.data.auto_section_data(attr_name)
+
+      element = _setup_bs_objs_init(data)
+
+      return element if data.nil?
+
+      return element unless data.rh_exist?(:list_values, :object) ||
+                            data[:depends_on].is_a?(Array)
+
+      _setup_bs_list_query(dependencies, attr_name, data, element)
+
+      # ensure attribute dependency is dynamically added to the list of
+      # object deps.
+      _setup_bs_objs_new_dep(dependencies, attr_name, element)
+
+      element[:depends_on] = []
+      element[:depends_on] = data[:depends_on] if data[:depends_on].is_a?(Array)
+
+      group = element[:group]
+      if group[:objs].length > 0
+        _setup_set_group_level(dependencies, attrs_done, attr_name,
+                               group, group[:objs].sort)
+      else
+        _setup_set_group_level(dependencies, attrs_done, attr_name,
+                               group, [element[:obj]])
+      end
+
+      _setup_attrs_depends_on(dependencies, attr_name,
+                              element[:depends_on])
+
+      element
+    end
+
+    # Initialize attribute element.
+    def _setup_bs_objs_init(data)
+      element = { :obj => nil, :setup => false, :ask_sort => nil,
+                  :group => { :objs => [], :attrs => [] },
+                  :attrs => [], :ask_step => nil }
+
+      return element if data.nil?
+
+      element[:setup] = data[:account] if data.rh_get(:account).boolean?
+      if data.rh_get(:ask_sort).is_a?(Fixnum)
+        element[:ask_sort] = data[:ask_sort]
+      end
+
+      element[:ask_step] = data[:ask_step]
+
+      element
+    end
+
+    # Internal function to verify if any attributes adds an object dependency
+    #
+    def _setup_bs_objs_new_dep(dependencies, parent_attr_name, element)
+      attrs = (element[:attrs] + element[:group][:attrs]).uniq
+      return if attrs.length == 0
+
+      found = false
+
+      attrs.each do |attr_name|
+        obj_found = dependencies.rh_get(:attributes, attr_name, :obj)
+        next if obj_found.nil?
+
+        objs = element.rh_get(:group, :objs)
+        next if objs.include?(obj_found)
+
+        dep = dependencies.rh_get(:attributes, attr_name)
+        # Updating list of deps objs
+        objs << obj_found
+        objs = (objs + dep[:group][:objs]).uniq
+        element.rh_set(objs, :group, :objs)
+
+        # Undating list of deps attributes
+        attrs = element.rh_get(:group, :attrs)
+        attrs_found = (attrs + dep[:attrs] + dep[:group][:attrs]).uniq
+        element.rh_set(attrs_found, :group, :attrs)
+
+        Lorj.debug(4, "attr setup '%s': '%s' dependent attribute adds a new"\
+                      " object dependency '%s'",
+                   parent_attr_name, attr_name, obj_found)
+        found = true
+      end
+      return unless found
+
+      Lorj.debug(5, "attr setup '%s': query '%s' (+ %s) and "\
+                    "requires '%s' (+ %s)", parent_attr_name,
+                 element[:obj], element[:group][:objs],
+                 element[:attrs], element[:group][:attrs] - element[:attrs])
+    end
+
+    def _setup_bs_list_query(dependencies, attr_name, data, element)
+      return unless data.rh_exist?(:list_values, :object)
+
+      element[:obj] = data.rh_get(:list_values, :object)
+      element[:group] = _setup_bs_objs_deps(dependencies, element[:obj])
+
+      _object_params_event(element[:obj], :query_e, :data).each do |attr_obj|
+        element[:attrs] << attr_obj.key_tree
+      end
+      Lorj.debug(5, "attr setup '%s': query '%s' (+ %s) and "\
+                    "requires '%s' (+ %s)", attr_name,
+                 element[:obj], element[:group][:objs],
+                 element[:attrs], element[:group][:attrs] - element[:attrs])
+    end
+
+    # Function to initialize the level to 0 for the current attribute.
+    # def _setup_set_level(dependencies, attr_name)
+    #   level = dependencies.rh_get(:attributes, attr_name, :level)
+    #   if level.nil?
+    #     level = 0
+    #   else
+    #     level += -1
+    #   end
+    #   level
+    # end
+
+    # Function to increase level (-1) for the list of attributes.
+    # def _setup_increase_level(dependencies, attrs)
+    #   attrs.each do |a|
+    #     unless dependencies.rh_exist?(:attributes, a, :level)
+    #       dependencies.rh_set(0, :attributes, a, :level)
+    #     end
+    #     dependencies[:attributes][a][:level] += -1
+    #   end
+    # end
+
+    # Function parsing the attrs_done to found equivalent group or subgroup.
+    #
+    # - 1. search for equivalent group
+    #   copy the equivalent group level to the group tested.
+    #   return if updated
+    #
+    # - 2. search for any subgroup already treated.
+    #   The group will get the highest level
+    #   each subgroup (part of the new group) will be decreased.
+    #   return if updated
+    #
+    # - 3. loop in groups if the tested group is a subgroup of an existing group
+    #   The group tested will get the lowest group level - 1
+    #   return if updated
+    #
+    # - 4. the group level is set with -1
+    #
+    def _setup_set_group_level(dependencies, attrs_done, attr_name, group, objs)
+      return unless _setup_set_group_case1(attrs_done, attr_name, group, objs)
+      return unless _setup_set_group_case2(dependencies, attrs_done,
+                                           attr_name, group, objs)
+
+      _setup_set_group_case34(attrs_done, attr_name, group, objs)
+    end
+
+    # Case 1 - equivalent group?
+    def _setup_set_group_case1(attrs_done, attr_name, group, objs)
+      attrs_done.each do |k, v|
+        next unless v.rh_get(:group, :objs) == objs ||
+                    (v.rh_get(:group, :objs).length == 0 && v[:obj] == objs[0])
+
+        group[:level] = v.rh_get(:group, :level)
+        Lorj.debug(5, "attr setup '%s': Equivalent: '%s' group level set to %s",
+                   attr_name, k, group[:level])
+        return false
+      end
+      true
+    end
+
+    # case 2 - existing group found as subgroup?
+    def _setup_set_group_case2(dependencies, attrs_done, attr_name, group, objs)
+      attr_subgroups = []
+      level = nil
+      attrs_done.each do |k, v|
+        group_to_check = v.rh_get(:group, :objs)
+        next if objs - [v[:obj]] == objs && objs - group_to_check == objs
+
+        attr_subgroups << k
+        if level.nil?
+          level = v.rh_get(:group, :level)
+        else
+          level = [v.rh_get(:group, :level), level].max
+        end
+      end
+
+      if level
+        group[:level] = level
+        Lorj.debug(5, "attr setup '%s': group level set to %s",
+                   attr_name, group[:level])
+
+        attr_subgroups.each do |v|
+          group = dependencies.rh_get(:attributes, v, :group)
+          group[:level] += -1
+          Lorj.debug(5, "attr setup '%s': attribute subgroup '%s' level"\
+                        ' decreased: group level set to %s',
+                     attr_name, v, group[:level])
+        end
+        return false
+      end
+      true
+    end
+
+    # case 3 - Is a subgroup of existing group?
+    def _setup_set_group_case34(attrs_done, attr_name, group, objs)
+      group[:level] = -1 # default is case 4 - new group!
+
+      attrs_done.each_value do |v|
+        group_to_check = v.rh_get(:group, :objs)
+        next if group_to_check - objs == group_to_check
+
+        group[:level] = [group[:level], v.rh_get(:group, :level) - 1].min
+      end
+      Lorj.debug(5, "attr setup '%s': group level set to '%s'",
+                 attr_name, group[:level])
+    end
+
+    # Internal setup function - Extract object data information.
+    def _setup_bs_objs_deps(dependencies, object_type)
+      group = { :objs => nil, :attrs => nil }
+      if dependencies.rh_exist?(:objects, object_type)
+        group[:objs], group[:attrs] = _setup_objects_attr_needs(dependencies,
+                                                                object_type)
+        return group
+      end
+      _setup_identify_dep_init(dependencies, object_type)
+      group[:objs], _, group[:attrs] = _setup_identify_deps(dependencies,
+                                                            object_type)
+      group
+    end
+
+    # Internal setup function - Build list of ALL attributes required for an
+    # object
+    #
+    # It navigates on loaded dependencies to build the list of attributes.
+    def _setup_objects_attr_needs(dependencies, object_type)
+      attrs = []
+
+      objects = dependencies.rh_get(:objects, object_type, :objects)
+      deps_objects = []
+      objects.each do |o|
+        attrs += dependencies.rh_get(:objects, o, :attrs)
+        found_obj, deps_attrs = _setup_objects_attr_needs(dependencies, o)
+        attrs += deps_attrs
+        deps_objects += found_obj
+      end
+      [(objects + deps_objects).uniq, attrs.uniq]
+    end
+
+    # Internal setup function - Identify a list of attributes from depends_on
+    #
+    # If the attribute has a object dependency, attributes attached are added.
+    # If the object has depends_on
+    def _setup_attrs_depends_on(dependencies, attr_name, attrs)
+      return [] unless attrs.is_a?(Array) && attrs.length > 0
+
+      result = []
+
+      Lorj.debug(3, "%s: depends on added '%s'", attr_name, attrs.join(', '))
+
+      attrs.each do |a|
+        data = Lorj.data.auto_section_data(a)
+
+        if data.rh_exist?(:list_values, :object)
+          element = _setup_bs_objs_deps(dependencies,
+                                        data.rh_get(:list_values, :object))
+          element[:attrs] += dependencies.rh_get(:object, element[:obj], :attrs)
+        else
+          element = { :attrs => [] }
+        end
+
+        if data[:depends_on].is_a?(Array)
+          element[:depends_on] = _setup_attrs_depends_on(dependencies, a,
+                                                         data[:depends_on])
+        else
+          element[:depends_on] = []
+        end
+
+        attrs_list = element[:attrs] + element[:depends_on]
+        attrs_list.uniq!
+        result += attrs_list
       end
+      result.uniq
     end
+    # rubocop: enable Metrics/CyclomaticComplexity
+
+    # Internal setup function - set/get dep level for an object
+    # def _setup_build_so_obj_level(obj_data_level, name, order_index)
+    #   return 0 if name.nil?
+
+    #   return obj_data_level[name] if obj_data_level.key?(name)
+
+    #   obj_data_level[name] = order_index
+    # end
+
+    # Internal setup function initializing a model object
+    #
+    def _setup_identify_dep_init(dependencies, object_type, path = [])
+      if path.include?(object_type)
+        PrcLib.warning('Loop detection: Be careful! a loop is detected with'\
+                       " the dependency from '%s' to '%s'. "\
+                       'Dependency ignored.', path.join('/'), object_type)
+        return false
+      end
+
+      return false if dependencies.rh_exist?(:objects, object_type)
+
+      model_object = { :objects => [], :objects_attrs => [], :attrs => [] }
+
+      dependencies.rh_set(model_object, :objects, object_type)
+      true
+    end
+
+    # Internal setup function to identify data to ask
+    # Navigate through objects dependencies to determine the need.
+    # def _setup_identify_obj_params(setup_steps,
+    #                                inspected_objects, objs_to_inspect,
+    #                                attr_name, attr_params)
+
+    #   attr_type = attr_params[:type]
+
+    #   case attr_type
+    #   when :data
+    #     return unless _setup_obj_param_is_data(setup_steps,
+    #                                            inspected_objects, attr_name)
+    #     inspected_objects << attr_name
+    #     return
+    #   when :CloudObject
+    #     return if objs_to_inspect.include?(attr_name) ||
+    #               inspected_objects.include?(attr_name)
+    #     # New object to inspect
+    #     objs_to_inspect << attr_name
+    #   end
+    # end
 
     def _setup_display_step(setup_step, step)
       Lorj.debug(2, 'Ask step %s:', step)
@@ -211,7 +1082,7 @@ module Lorj
 
         order_array = setup_steps[iStep][:order]
 
-        order_array.each_index do |iIndex|
+        order_array.each_key do |iIndex|
           Lorj.debug(2, 'Ask order %s:', iIndex)
           order_array[iIndex].each do |data|
             options = _get_meta_data(data)