lorj 1.0.1 → 1.0.2

data/lib/core/core_setup_ask.rb

@@ -54,6 +54,10 @@ module Lorj
 
         @config.set(data, value)
 
+        section = _get_account_section(data)
+        @config.set(data, value, :name =>
+                    'account', :section => section) unless section.nil?
+
         break if options[:post_step_function].nil?
 
         proc = options[:post_step_function]
@@ -89,8 +93,9 @@ module Lorj
       when :process_call
         result = _setup_list_from_process_call(obj_to_load, list_options)
       else
-        runtime_fail "'%s' invalid. %s/list_values/values_type supports '%s'.",
-                     list_options[:values_type], data, [:provider_function]
+        PrcLib.runtime_fail "%s: '%s' invalid query type. valid is: '%s'.",
+                            obj_to_load, list_options[:values_type],
+                            [:controller_call, :query_call, :process_call]
       end
       result
     end
@@ -158,7 +163,7 @@ module Lorj
       say_msg = format("Select '%s' from the list:", desc)
       say_msg += format(' |%s|', default) unless default.nil?
       say(say_msg)
-      value = choose do | q |
+      value = choose do |q|
         q.choices(*list)
         q.default = default if default
       end
@@ -187,23 +192,27 @@ module Lorj
       default = options[:default_value] if default.nil?
       default = @config.get(data, default)
 
-      validate_proc = options[:validate_function]
+      # validate_proc = options[:validate_function]
       proc_ask = options[:ask_function]
 
       if proc_ask.nil?
-        proc_method = _ask
+        # proc_method = _ask(desc, default, valid_regex,
+        #                    is_encrypted, is_required)
+        value = _ask(desc, default, valid_regex,
+                     is_encrypted, is_required)
       else
-        proc_method = @process.method(proc_ask)
+        # proc_method = @process.method(proc_ask)
+        value = @process.method(proc_ask)
       end
 
-      loop do
-        value = proc_method.call(desc, default, valid_regex,
-                                 is_encrypted, is_required)
-        break if validate_proc.nil?
+      # loop do
+      #   value = proc_method.call(desc, default, valid_regex,
+      #                            is_encrypted, is_required)
+      #   break if validate_proc.nil?
 
-        validate_method = @process.method(validate_proc)
-        break if validate_method.call(value)
-      end
+      #   validate_method = @process.method(validate_proc)
+      #   break if validate_method.call(value)
+      # end
       value
     end
 
@@ -223,11 +232,12 @@ module Lorj
     # *raise*:
     #
     def _ask(sDesc, default, rValidate, bEncrypted, bRequired)
+      value = nil
       loop do
         if bEncrypted
           value = _ask_encrypted(sDesc, default)
         else
-          value = ask(format('Enter %s:[%s]', sDesc, default)) do |q|
+          value = ask(format('Enter %s:', sDesc)) do |q|
             q.default = default unless default.nil?
             q.validate = rValidate unless rValidate.nil?
           end

data/lib/core/core_setup_encrypt.rb

@@ -52,7 +52,10 @@ module Lorj
         }
 
         Lorj.debug(2, "Writing '%s' key file", key_file)
-        File.open(key_file, 'w') do |out|
+        PrcLib.ensure_dir_exists(
+          PrcLib.pdata_path
+        ) unless PrcLib.dir_exists?(PrcLib.pdata_path)
+        File.open(key_file, 'w+') do |out|
           out.write(Base64.encode64(entr.to_yaml))
         end
       else
@@ -81,16 +84,15 @@ module Lorj
       value_hidden = ''
       begin
         value_hidden = '*' * Encryptor.decrypt(
-           :value => Base64.strict_decode64(enc_value),
-           :key => entr[:key],
-           :iv => Base64.strict_decode64(entr[:iv]),
-           :salt => entr[:salt]
+          :value => Base64.strict_decode64(enc_value),
+          :key => entr[:key],
+          :iv => Base64.strict_decode64(entr[:iv]),
+          :salt => entr[:salt]
         ).length
       rescue
-        Lorj.error('Unable to decrypt your %s. You will need to re-enter it.',
-                   sDesc)
+        PrcLib.error('Unable to decrypt your %s. You will need to re-enter it.',
+                     sDesc)
       else
-        value_hidden = format('[%s]', value_hidden)
         PrcLib.message("'%s' is already set. If you want to keep it,"\
                        ' just press Enter', sDesc)
       end
@@ -119,7 +121,7 @@ module Lorj
       value_free = ''
       while value_free == ''
         # ask for encrypted data.
-        value_free = ask(format('Enter %s: [%s]', sDesc, value_hidden)) do |q|
+        value_free = ask(format('Enter %s: |%s|', sDesc, value_hidden)) do |q|
           q.echo = '*'
         end
         if value_free == '' && enc_value
@@ -134,12 +136,12 @@ module Lorj
         end
       end
       Base64.strict_encode64(
-         Encryptor.encrypt(
-            :value => value_free,
-            :key => entr[:key],
-            :iv => Base64.strict_decode64(entr[:iv]),
-            :salt => entr[:salt]
-         )
+        Encryptor.encrypt(
+          :value => value_free,
+          :key => entr[:key],
+          :iv => Base64.strict_decode64(entr[:iv]),
+          :salt => entr[:salt]
+        )
       )
     end
   end

data/lib/core/core_setup_init.rb

@@ -37,9 +37,9 @@ module Lorj
     # * *Raises* :
     #
     def _setup_load
-      ask_steps = Lorj.defaults.get[:setup, :ask_step]
+      ask_steps = Lorj.defaults.data.rh_get(:setup, :ask_step)
       setup_steps = []
-      ask_steps.each do | value |
+      ask_steps.each do |value|
         setup_steps << {
           :desc => value[:desc],
           :explanation => value[:explanation],
@@ -63,12 +63,12 @@ module Lorj
     # * *Raises* :
     #
     def _setup_check_additional(setup_steps)
-      setup_steps.each_index do | step |
+      setup_steps.each_index do |step|
         value = setup_steps[step]
         next unless value.rh_exist?(:add)
 
         datas_to_add = value.rh_get(:add)
-        datas_to_add.each do | data_to_add |
+        datas_to_add.each do |data_to_add|
           order_array = setup_steps[step][:order]
           next if _setup_attr_already_added?(order_array, data_to_add)
 
@@ -145,11 +145,13 @@ module Lorj
       Lorj.debug(2, 'Ask step %s:', step)
       puts ANSI.bold(setup_step[:desc]) unless setup_step[:desc].nil?
       begin
-        erb_msg = ANSI.yellow(erb(setup_step[:explanation]))
+        erb_msg = ANSI.yellow(
+          erb(setup_step[:explanation])
+        ) unless setup_step[:explanation].nil?
       rescue => e
-        PrcLib.Error "setup step '%d/:explanation' : %s", step, e.message
+        PrcLib.error "setup step '%d/:explanation' : %s", step, e.message
       end
-      puts format("%s\n\n", erb_msg) unless setup_step[:explanation].nil?
+      puts format("%s\n\n", erb_msg) unless erb_msg.nil?
     end
 
     # internal setup function to display step information
@@ -172,14 +174,14 @@ module Lorj
                       data,
                       erb(options[:explanation]))
         rescue => e
-          PrcLib.Error "setup key '%s/:explanation' : %s", data, e.message
+          PrcLib.error "setup key '%s/:explanation' : %s", data, e.message
         end
       end
 
       begin
         desc = erb(options[:desc]) unless options[:desc].nil?
       rescue => e
-        PrcLib.Error "setup key '%s/:desc' : %s", data, e.message
+        PrcLib.error "setup key '%s/:desc' : %s", data, e.message
       end
 
       desc
@@ -202,22 +204,24 @@ module Lorj
     #
     def _setup_ask(setup_steps)
       # Ask for user input
-      setup_steps.each_index do | iStep |
-        _setup_display_step(setup_step, iStep)
+      # TODO: Enhance to support section::data to avoid duplicated data name
+      #   against sections.
+      setup_steps.each_index do |iStep|
+        _setup_display_step(setup_steps[iStep], iStep)
 
         order_array = setup_steps[iStep][:order]
 
-        order_array.each_index do | iIndex |
+        order_array.each_index do |iIndex|
           Lorj.debug(2, 'Ask order %s:', iIndex)
-          order_array[iIndex].each do | data |
-            options = _get_meta_data(data)
+          order_array[iIndex].each do |data|
+            options = _get_meta_data_auto(data)
             options = {} if options.nil?
 
             data_desc = _setup_display_data(data, options)
 
             if options[:pre_step_function]
               proc = options[:pre_step_function]
-              next unless @oForjProcess.method(proc).call(data)
+              next unless @process.method(proc).call(data)
             end
 
             _setup_ask_data(data_desc, data, options)

data/lib/core/core_setup_list.rb

@@ -43,23 +43,23 @@ module Lorj
       PrcLib.message("Loading #{obj_to_load}.")
 
       object = @object_data[obj_to_load, :ObjectData]
-      object = Create(obj_to_load) if object.nil?
+      object = process_create(obj_to_load) if object.nil?
       return nil if object.nil?
 
       params = ObjectData.new
       params.add(object)
       params << list_options[:query_params]
 
-      runtime_fail '%s: query_type => :controller_call '\
+      PrcLib.runtime_fail '%s: query_type => :controller_call '\
                    'requires missing :query_call declaration'\
                    ' (Controller function)',
-                   data if list_options[:query_call].nil?
+                          data if list_options[:query_call].nil?
 
       proc = list_options[:query_call]
       begin
         list = @controller.method(proc).call(obj_to_load, params)
       rescue => e
-        runtime_fail "Error during call of '%s':\n%s", proc, e.message
+        PrcLib.runtime_fail "Error during call of '%s':\n%s", proc, e.message
       end
       { :list => list, :default_value => nil }
     end
@@ -83,10 +83,10 @@ module Lorj
       query_hash = list_options[:query_params]
       query_hash = {} if query_hash.nil?
 
-      object_list = query(obj_to_load, query_hash)
+      object_list = process_query(obj_to_load, query_hash)
 
       list = []
-      object_list.each { | oElem | list << oElem[list_options[:value]] }
+      object_list.each { |oElem| list << oElem[list_options[:value]] }
 
       { :list => list.sort!, :default_value => nil }
     end
@@ -94,11 +94,11 @@ module Lorj
     def _setup_build_process_params(option_params, params)
       return if option_params.nil?
 
-      option_params.each do | key, value |
+      option_params.each do |key, value|
         match_res = value.match(/lorj::config\[(.*)\]/)
         if match_res
           extract = match_res[1].split(', ')
-          extract.map! { | v | v[1..-1].to_sym if v[0] == ':' }
+          extract.map! { |v| v[1..-1].to_sym if v[0] == ':' }
           params << { key => config[extract] }
         else
           params << { key => value }
@@ -120,10 +120,10 @@ module Lorj
     # * *Raises* :
     #
     def _setup_list_from_process_call(obj_to_load, list_options)
-      runtime_fail '%s: query_type => :process_call'\
+      PrcLib.runtime_fail '%s: query_type => :process_call'\
                    ' requires missing :query_call declaration'\
                    ' (Provider function)',
-                   data if list_options[:query_call].nil?
+                          data if list_options[:query_call].nil?
       proc = list_options[:query_call]
       obj_to_load = list_options[:object]
       PrcLib.debug(2, "Running process '#{proc}' on '#{obj_to_load}'.")
@@ -138,8 +138,8 @@ module Lorj
         proc_method = @process.method(proc)
         result = proc_method.call(obj_to_load, params)
       rescue => e
-        runtime_fail "Error during call of '%s':\n%s",
-                     proc, e.message
+        PrcLib.runtime_fail "Error during call of '%s':\n%s",
+                            proc, e.message
       end
 
       if result.is_a?(Hash)

data/lib/core/definition.rb

@@ -68,7 +68,7 @@ module Lorj
       PrcLib.model.heap true
       supported_options = [:use_controller]
       unless hOptions.nil?
-        hOptions.each_key do | key |
+        hOptions.each_key do |key|
           case key
           when :use_controller
             value = hOptions.rh_get(:use_controller)
@@ -127,7 +127,7 @@ module Lorj
       lorj_object = PrcLib.model.meta_obj.rh_get(obj_type_name)
 
       # Checking handlers_options data
-      handlers = _verify_handlers(obj_type_name, lorj_object, handlers)
+      _verify_handlers(obj_type_name, lorj_object, handlers)
 
       if lorj_object.nil?
         lorj_object = _define_obj_initialize(obj_type_name, handlers)
@@ -241,10 +241,10 @@ module Lorj
       key_path = KeyPath.new(key)
 
       PrcLib.model.meta_obj.rh_set(nil, PrcLib.model.object_context,
-                                   :returns, key_path.sFullPath)
+                                   :returns, key_path.fpath)
       PrcLib.model.attribute_context key_path
       Lorj.debug(4, "%s: Undefining attribute mapping '%s'",
-                 PrcLib.model.object_context, key_path.sFullPath)
+                 PrcLib.model.object_context, key_path.fpath)
 
       _query_mapping(key, nil)
     end
@@ -315,7 +315,7 @@ module Lorj
       value = { data => { :options => hOptions } }
 
       PrcLib.model.predefine_data_value.rh_set(value,
-                                               key_path.sFullPath, :values)
+                                               key_path.fpath, :values)
     end
 
     # function to interpret a template data, and use ERBConfig as data context.
@@ -376,11 +376,11 @@ module Lorj
 
       return nil unless _decl_data_valid?(value, map)
 
-      object_type = PrcLib.model.object_context(fct_context)
+      object_type = PrcLib.model.object_context
 
       key_path = PrcLib.model.attribute_context __callee__
 
-      keypath = key_path.sFullPath
+      keypath = key_path.fpath
       Lorj.debug(2, "%s-%s: Attribute value mapping '%s' => '%s'",
                  object_type, key_path.to_s, value, map)
       PrcLib.model.meta_obj.rh_set(map,
@@ -437,7 +437,7 @@ module Lorj
 
       object_type = PrcLib.model.object_context(fct_context)
 
-      key_access = KeyPath.new(attr_name).sFullPath
+      key_access = KeyPath.new(attr_name).fpath
 
       # PrcLib.model.meta_obj://<Object>/:params/:keys/<keypath> must exist.
       object_param = PrcLib.model.meta_obj.rh_get(object_type,
@@ -468,8 +468,8 @@ module Lorj
 
       PrcLib.model.attribute_context key_path
 
-      PrcLib.model.meta_obj.rh_set(map_path_obj.sFullPath, object_type,
-                                   :query_mapping, key_path.sFullPath)
+      PrcLib.model.meta_obj.rh_set(map_path_obj.fpath, object_type,
+                                   :query_mapping, key_path.fpath)
     end
 
     # Internal function to store object attribute and mapping information
@@ -485,14 +485,14 @@ module Lorj
 
       map_path_obj = KeyPath.new(map)
 
-      PrcLib.model.meta_obj.rh_set(map_path_obj.sFullPath, object_type,
-                                   :returns, key_path_obj.sFullPath)
+      PrcLib.model.meta_obj.rh_set(map_path_obj.fpath, object_type,
+                                   :returns, key_path_obj.fpath)
 
       PrcLib.model.attribute_context key_path_obj
 
       return if options[:not_queriable] == true
       query_mapping(key, map)
-      [key_path_obj.sFullPath, map_path_obj.sFullPath]
+      [key_path_obj.fpath, map_path_obj.fpath]
     end
 
     # Internal section detection
@@ -516,8 +516,8 @@ module Lorj
     # Internal model data validation
     # return true if valid. false otherwise.
     def self._decl_data_valid?(value, map)
-      return false if [String, Symbol].include?(value.class)
-      return false if [NilClass, Symbol, String].include?(map.class)
+      return false unless [String, Symbol].include?(value.class)
+      return false unless [NilClass, Symbol, String].include?(map.class)
       true
     end
 
@@ -535,7 +535,7 @@ module Lorj
                                                    :params)
 
       PrcLib.model.attribute_context KeyPath.new(name)
-      key_access = PrcLib.model.attribute_context.sFullPath
+      key_access = PrcLib.model.attribute_context.fpath
 
       unless top_param_obj[:keys].key?(key_access)
         top_param_obj[:keys][key_access] = {}
@@ -551,10 +551,10 @@ module Lorj
 
       case type
       when :data
-        return _obj_needs_data(params[:keys][attribute.sFullPath],
+        return _obj_needs_data(params[:keys][attribute.fpath],
                                msg_action, options)
       when :CloudObject, :object
-        return _obj_needs_object(params[:keys][attribute.sFullPath],
+        return _obj_needs_object(params[:keys][attribute.fpath],
                                  options)
       end
       PrcLib.dcl_fail("%s: Object parameter type '%s' unknown.",
@@ -651,8 +651,8 @@ module Lorj
       return handlers if object.nil?
 
       handlers_list = object[:lambdas].keys.join(', ')
-      handlers.each_key do | key |
-        next if lorj_object.rh_exist?(:lambdas, key)
+      handlers.each_key do |key|
+        next if object.rh_exist?(:lambdas, key)
 
         PrcLib.dcl_fail("'%s' parameter is invalid. Use '%s'",
                         key, handlers_list)

data/lib/core/definition_internal.rb

@@ -34,6 +34,16 @@ module Lorj
       meta_default.merge!(meta)
     end
 
+    def _get_meta_data_auto(key)
+      return nil if key.nil?
+      Lorj.defaults.get_meta_auto(key)
+    end
+
+    def _get_account_section(key)
+      return nil if key.nil?
+      Lorj.defaults.get_meta_section(key)
+    end
+
     # internal runtime function for process call
     # Get the controller result and map controller object data to
     # lorj object attributes, using controller mapping function.
@@ -67,7 +77,7 @@ module Lorj
         value = _call_controller_map(map_handler, oControlerObject,
                                      map_obj.tree)
         value = _mapping_data(object_type, key_obj, object_opts, value)
-        attr_value.rh_set(value, key_path.tree)
+        attr_value.rh_set(value, key_obj.tree)
       end
       attr_value
     end
@@ -152,15 +162,15 @@ module Lorj
     def _mapping_data(object_type, key_obj, object_opts, value)
       value_mapping = object_opts.rh_get(:value_mapping, key_obj.fpath)
       if value_mapping && !value.nil?
-        value_mapping.each do | map_key, map_value |
+        value_mapping.each do |map_key, map_value|
           next unless value == map_value
           Lorj.debug(5, "Object '%s' value mapped '%s': '%s' => '%s'",
                      object_type, key_obj.tree,
                      value, map_value)
           return map_key
         end
-        runtime_fail("'%s.%s': No controller value mapping for '%s'.",
-                     object_type, key_obj.tree, value)
+        PrcLib.runtime_fail("'%s.%s': No controller value mapping for '%s'.",
+                            object_type, key_obj.tree, value)
       end
 
       Lorj.debug(5, "Object '%s' value '%s' extracted: '%s'",
@@ -198,9 +208,9 @@ module Lorj
         object_missing << object_type
       end
 
-      attr_paths.each do | _attr_path, attr_options|
+      attr_paths.each do |attr_path, attr_options|
         next if attr_options[:for] && !attr_options[:for].include?(sEventType)
-        _check_required_attr(object_missing, attr_name, attr_options, fname)
+        _check_required_attr(object_missing, attr_path, attr_options, fname)
       end
       object_missing
     end
@@ -212,16 +222,16 @@ module Lorj
     #
     # *parameters*:
     #   - +object_missing+ : Array of missing object for process caller.
-    #   - +attr_name+      : attribute/data name
-    #   - +attr_options+   : attribute options
-    #   - +fname+          : caller function
+    #   - +attr_path+      : String. Attribute/data path (See KeyPath.fpath)
+    #   - +attr_options+   : Hash. Attribute options
+    #   - +fname+          : String. Caller function
     #
     # *return*:
     #
     # *raise*:
     # - runtime error if required data is not set. (empty or nil)
     #
-    def _check_required_attr(object_missing, attr_name, attr_options, fname)
+    def _check_required_attr(object_missing, attr_path, attr_options, fname)
       attr_obj = KeyPath.new(attr_path)
 
       attr_name = attr_obj.key

data/lib/core/lorj_basecontroller.rb

@@ -31,37 +31,37 @@ module Lorj
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Create functions.
     def connect(_sObjectType, _hParams)
-      process_error 'connect has not been redefined by the controller.'
+      controller_error 'connect has not been redefined by the controller.'
     end
 
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Create functions.
     def create(_sObjectType, _hParams)
-      process_error 'create_object has not been redefined by the controller.'
+      controller_error 'create_object has not been redefined by the controller.'
     end
 
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Delete functions.
     def delete(_sObjectType, _hParams)
-      process_error 'delete_object has not been redefined by the controller.'
+      controller_error 'delete_object has not been redefined by the controller.'
     end
 
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Get functions.
     def get(_sObjectType, _sUniqId, _hParams)
-      process_error 'get_object has not been redefined by the controller.'
+      controller_error 'get_object has not been redefined by the controller.'
     end
 
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Query functions.
     def query(_sObjectType, _sQuery, _hParams)
-      process_error 'query_object has not been redefined by the controller.'
+      controller_error 'query_object has not been redefined by the controller.'
     end
 
     # Default handlers which needs to be defined by the controller,
     # called by BaseDefinition Update functions.
     def update(_sObjectType, _oObject, _hParams)
-      process_error 'update_object has not been redefined by the controller.'
+      controller_error 'update_object has not been redefined by the controller.'
     end
 
     # Simply raise an error
@@ -74,7 +74,7 @@ module Lorj
     #  - Lorj::PrcError
     def controller_error(msg, *p)
       msg = format(msg, *p)
-      runtime_fail '%s: %s', self.class, msg
+      fail Lorj::PrcError.new, format('%s: %s', self.class, msg)
     end
 
     # check if required data is loaded. raise an error if not
@@ -89,7 +89,7 @@ module Lorj
     def required?(oParams, *key)
       return if oParams.exist?(key)
 
-      runtime_fail '%s: %s is not set.', self.class, key
+      controller_error '%s is not set.', key
     end
   end
 end