lorj 1.0.16 → 1.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df0501318f36deb3f6d31fdce4d63f148d91a818
-  data.tar.gz: 6800e36135d9decb469b1d9dc87e1f3be7385980
+  metadata.gz: fd2e3ef16b60623e7d392719983d1c656b90cb73
+  data.tar.gz: 5342df87489d1d9feacf527edce9a1ca321358d0
 SHA512:
-  metadata.gz: b14d5a49cfe34e91495e412e1c64041ecad1c38927dda2c555e4b57d2589182863a1bbe6e49492639638d6ecdc8121895f667878d77f91ca5ef32a944b20f87b
-  data.tar.gz: 61d2970cecf4ba70bb01135ecfcc6813bf43ff89c708aa0e29c716975881562cca13b611d533414f263a9d289ddaada7bea8a6fdb83ea43d1abd0ea4b60b6592
+  metadata.gz: 0dcd158c91dfeb3d058e0f7374a167ba7efaf9974c14b0b734875d020e3ed9bd4333432adec1a2680d07cb2999ea4c7d31865013b7e6e918319675b7e0814236
+  data.tar.gz: eac85b8e31ca9c05cb7002f1064e4f121fd1254d3673c9baae4c1f12c337a512c9c3008018f626edbe5f0d113ae961fdbd2570319a29c07b2fcea05bbbd57458

data/bin/lorj_account_import.rb

@@ -48,14 +48,20 @@ class Test < Lorj::BaseDefinition
 
   private
 
+  # Test if the encryted data (if encrypted) is readable
   def account_key_test
-    entr = _get_encrypt_key
-    data = @core.config['credentials#account_key']
-
-    res = Lorj::SSLCrypt.get_encrypted_value(data, entr,
-                                             'credentials#account_key')
-
-    test_state(!res.nil?, 'Account key', data)
+    key = 'credentials#account_key'
+    opts = Lorj.data.auto_section_data(key)
+    data = @core.config[key]
+    if opts[:encrypted].is_a?(TrueClass)
+      entr = _get_encrypt_key
+
+      res = Lorj::SSLCrypt.get_encrypted_value(data, entr, key)
+      status = !res.nil?
+    else
+      status = true
+    end
+    test_state(status, key, data)
   end
 
   def test_state(res, test, value)

data/lib/core/core.rb

@@ -347,9 +347,11 @@ module Lorj
     #   - env_hash: String. Base64 encrypted Hash.
     #   OR
     #   - nil if issues.
-    def account_export(map = nil, with_name = true)
+    def account_export(map = nil, with_name = true, account_only = false,
+                       processes_options = {})
       return nil if @core_object.nil?
-      @core_object.account_export(map, with_name)
+      @core_object.account_export(map, with_name, account_only,
+                                  processes_options)
     end
 
     # Core parameters are:

data/lib/core/core_import_export.rb

@@ -139,13 +139,16 @@ module Lorj
     #     True by default.
     #   - +account_only+ : True data extracted must come exclusively from the
     #     config 'account' layer.
+    #   - +processes_options+ : Hash. Export options for processes
+    #     - :exclude: Array. name of process to exclude.
     #
     # * *returns* :
     #   - key: String. Key used to encrypt.
     #   - env_hash: String. Base64 encrypted Hash.
     #   OR
     #   - nil if issues.
-    def account_export(map = nil, with_name = true, account_only = true)
+    def account_export(map = nil, with_name = true, account_only = true,
+                       processes_options = {})
       map = _account_map if map.nil?
 
       map.merge!('account#name' => {}, 'account#provider' => {}) if with_name
@@ -172,21 +175,26 @@ module Lorj
       entr = Lorj::SSLCrypt.new_encrypt_key
       export_data = { :enc_data => Lorj::SSLCrypt.encrypt_value(rhash.to_yaml,
                                                                 entr) }
-      export_data[:processes] = _export_processes
+      export_data[:processes] = _export_processes(processes_options)
       [entr, export_data.to_yaml]
     end
 
     private
 
-    def _export_processes
+    def _export_processes(processes_options)
       export_data = []
       PrcLib.processes.each do |p|
         next unless p.key?(:process_name) && p.key?(:lib_name)
 
+        next if processes_options[:exclude].is_a?(Array) &&
+                processes_options[:exclude].include?(p[:process_name])
+
         process = {}
         process[:process_module] = p[:process_name]
         process[:lib_name] = p[:lib_name]
-        process[:controller] = p[:controller_name] if p.key?(:controller_name)
+        if p.key?(:controller_name)
+          process[:controller_name] = p[:controller_name]
+        end
         export_data << process if process.length > 0
       end
       export_data

data/lib/core/definition.rb

@@ -480,7 +480,7 @@ module Lorj
     # Internal function
     def self._query_mapping(key, map)
       return nil unless [String, Symbol].include?(key.class)
-      return nil unless [NilClass, Symbol, String].include?(map.class)
+      return nil unless [NilClass, Symbol, String, Array].include?(map.class)
 
       object_type = PrcLib.model.object_context
       key_path = KeyPath.new(key)

data/lib/core/lorj_basecontroller.rb

@@ -104,7 +104,10 @@ module Lorj
       end
       controller_error '%s is not set.', key
     end
+  end
 
+  # Defining private internal controller functions
+  class BaseController
     private
 
     # controller helper function:
@@ -115,19 +118,40 @@ module Lorj
     #   - +objects+ : Collection of object which respond to each
     #   - +query+   : Hash. Containing a list of attributes to test
     #     See #ctrl_do_query_match for details
-    #   - +&block+  : block to extract the object data from a key.
-    def ctrl_query_each(objects, query) # :doc:
+    #   - +triggers+: Hash. Optional. Procs to interact at several places:
+    #     - :before  : &code(object) - To execute some code on the object
+    #       before extract.
+    #       *return* true to go on, or false to ignore the object.
+    #     - :after   : &code(object, query, selected) - To execute some code on
+    #       the object after extract.
+    #       This after trigger is the last change to select or not the object
+    #       for the query. Note that query structure defined by lorj by default.
+    #       *return* true if the object is selected. false otherwise.
+    #     - :extract : &code(object, key) - To execute the data extraction
+    #       This block is required only if call of [] or :<key> is not supported
+    #       *return* the value extracted.
+    #
+    def ctrl_query_each(objects, query, triggers = {}) # :doc:
       results = []
       Lorj.debug(4, "Filtering with '%s'", query)
       unless objects.class.method_defined?(:each)
         controller_error "'%s' do not have 'each' function.", objects.class
       end
       objects.each do |o|
-        if block_given?
-          selected = ctrl_do_query_match(o, query) { |d, k| yield d, k }
+        if [Proc, Method].include?(triggers[:before].class)
+          code = triggers[:before]
+          next unless code.call o
+        end
+        if [Proc, Method].include?(triggers[:extract].class)
+          code = triggers[:extract]
+          selected = ctrl_do_query_match(o, query) { |d, k| code.call d, k }
         else
           selected = ctrl_do_query_match(o, query)
         end
+        if [Proc, Method].include?(triggers[:after].class)
+          code = triggers[:after]
+          selected = code.call o, query, selected
+        end
         results.push o if selected
       end
       Lorj.debug(4, '%d records selected', results.length)
@@ -155,7 +179,7 @@ module Lorj
     #   - No exception
     #
     #   by default, this function will extract data from the object
-    #   with followinf functions: If one fails, it will try the next one.
+    #   with following functions: If one fails, it will try the next one.
     #   :[], or :key or &block.
     #   The optional &block is a third way defined by the controller to extract
     #   data.
@@ -171,15 +195,18 @@ module Lorj
     def ctrl_do_query_match(object, query)
       selected = true
       query.each do |key, match_value|
+        key_path = KeyPath.new(key)
         if block_given?
-          found, v = _get_from(object, key) { |d, k| yield d, k }
+          found, v = _get_from(object, key_path.tree) { |d, k| yield d, k }
         else
-          found, v = _get_from(object, key)
+          found, v = _get_from(object, key_path.tree)
         end
 
         Lorj.debug(4, "'%s.%s' = '%s'", object.class, key, v) if found
 
-        selected = lorj_filter_regexp(v, match_value)
+        selected  = lorj_filter_regexp(v,  match_value)
+        selected |= lorj_filter_hash(v,    match_value)
+        selected |= lorj_filter_array(v,   match_value)
         selected |= lorj_filter_default(v, match_value)
         break unless selected
       end
@@ -192,12 +219,20 @@ module Lorj
       query.select { |_k, v| limit.include?(v.class) }
     end
 
-    def _get_from(data, key)
+    def _get_from(data, *key)
       ret = nil
       found = nil
+      key.flatten!
+
+      if data.is_a?(Hash)
+        found = data.rh_exist?(*key)
+        ret = data.rh_get(*key)
+        return [found, ret]
+      end
 
-      [:[], key].each do |f|
-        found, ret = _get_from_func(data, key, f)
+      [:[], key[0]].each do |f|
+        found, ret = _get_from_func(data, key[0], f)
+        return _get_from(ret, key[1..-1]) if found && key.length > 1
         break if found
       end
       return [found, ret] if found || !block_given?
@@ -213,7 +248,7 @@ module Lorj
     end
 
     def _get_from_func(data, key, func = nil)
-      func = key if func.nil?
+      func = key[0] if func.nil?
       v = nil
       if data.class.method_defined?(func)
         begin
@@ -248,6 +283,42 @@ module Lorj
       false
     end
 
+    # Function to check if a value is found in an Array
+    #
+    # * *returns*:
+    #   - true if found
+    # OR
+    #   - false otherwise
+    #
+    def lorj_filter_array(value, match_value)
+      return false unless value.is_a?(Array) || match_value.is_a?(Array)
+
+      if value.is_a?(Array) && match_value.is_a?(Array)
+        return (value.sort == match_value.sort)
+      end
+
+      value.include?(match_value)
+    end
+
+    # Function to check if a value match a filter value.
+    #
+    # * *returns*:
+    #   - true if match
+    # OR
+    #   - false otherwise
+    #
+    def lorj_filter_hash(value, structure)
+      return false unless value.is_a?(Hash)
+
+      key_path = KeyPath.new(structure)
+      tree = key_path.tree[0..-2]
+      return false unless value.rh_exist?(tree)
+      match_value = key_path.key
+      res = value.rh_get(tree)
+      return lorj_filter_array(res.flatten, match_value) if res.is_a?(Array)
+      lorj_filter_default(res, match_value)
+    end
+
     # Function to check if a value match a filter value.
     #
     # * *returns*:

data/lib/core/lorj_basedefinition.rb

@@ -137,9 +137,9 @@ module Lorj
                             object_type, key_path_obj.key,
                             value unless value_mapping.rh_exist?(value)
 
-        result.rh_set(value_mapping[value], map_path.tree)
+        result.rh_set(value_mapping[value], map_path.to_s)
       else
-        result.rh_set(value, map_path.tree)
+        result.rh_set(value, map_path.to_s)
       end
       nil
     end

data/lib/core/lorj_baseprocess.rb

@@ -111,9 +111,11 @@ module Lorj
   class BaseProcess
     private
 
-    def account_export(map = nil, with_name = true, account_only = false) #:doc:
+    def account_export(map = nil, with_name = true, account_only = false,
+                       processes_options = {}) #:doc:
       fail Lorj::PrcError.new, 'No Base object loaded.' unless @base_object
-      @base_object.account_export(map, with_name, account_only)
+      @base_object.account_export(map, with_name, account_only,
+                                  processes_options)
     end
 
     def account_import(key, enc_hash, name = nil, controller = nil) #:doc:

data/lib/core/lorj_keypath.rb

@@ -34,8 +34,8 @@ module Lorj
   # oKey = KeyPath(:test)
   # puts oKey.to_s     # => 'test'
   # puts oKey.key      # => :test
-  # puts oKey.key[0]   # => :test
-  # puts oKey.key[1]   # => nil
+  # puts oKey.key(0)   # => :test
+  # puts oKey.key(1)   # => nil
   # puts oKey.fpath    # => ':test'
   # puts oKey.tree     # => [:test]
   # puts oKey.key_tree # => :test
@@ -43,8 +43,8 @@ module Lorj
   # oKey = KeyPath([:test,:test2,:test3])
   # puts oKey.to_s      # => 'test/test2/test3'
   # puts oKey.key       # => :test3
-  # puts oKey.key[0]    # => :test
-  # puts oKey.key[1]    # => :test2
+  # puts oKey.key(0)    # => :test
+  # puts oKey.key(1)    # => :test2
   # puts oKey.fpath     # => ':test/:test2/:test3'
   # puts oKey.tree      # => [:test,:test2,:test3]
   # puts oKey.key_tree  # => ':test/:test2/:test3'
@@ -52,8 +52,8 @@ module Lorj
   # oKey = KeyPath([:test, '{/.*/}', :test3])
   # puts oKey.to_s      # => 'test/{\/.*\/}/test3'
   # puts oKey.key       # => :test3
-  # puts oKey.key[0]    # => :test
-  # puts oKey.key[1]    # => '{/.*/}'
+  # puts oKey.key(0)    # => :test
+  # puts oKey.key(1)    # => '{/.*/}'
   # puts oKey.fpath     # => ':test/{\/.*\/}/:test3'
   # puts oKey.tree      # => [:test, '{/.*/}',:test3]
   # puts oKey.key_tree  # => ':test/{\/.*\/}/:test3'

data/lib/lorj/version.rb

@@ -16,6 +16,6 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.16'
-  DATE = '2015-06-25'
+  VERSION = '1.0.17'
+  DATE = '2015-06-26'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lorj
 version: !ruby/object:Gem::Version
-  version: 1.0.16
+  version: 1.0.17
 platform: ruby
 authors:
 - forj team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-25 00:00:00.000000000 Z
+date: 2015-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler