lorj 1.0.17 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd2e3ef16b60623e7d392719983d1c656b90cb73
-  data.tar.gz: 5342df87489d1d9feacf527edce9a1ca321358d0
+  metadata.gz: ae29eb4daeb919aafeedcc2312d5f56c48f55384
+  data.tar.gz: b29b195d80a8c1e0cfd5435db8f405fa8f850a59
 SHA512:
-  metadata.gz: 0dcd158c91dfeb3d058e0f7374a167ba7efaf9974c14b0b734875d020e3ed9bd4333432adec1a2680d07cb2999ea4c7d31865013b7e6e918319675b7e0814236
-  data.tar.gz: eac85b8e31ca9c05cb7002f1064e4f121fd1254d3673c9baae4c1f12c337a512c9c3008018f626edbe5f0d113ae961fdbd2570319a29c07b2fcea05bbbd57458
+  metadata.gz: 561aaad92e549e7ed3a1384c2c4d2e7848c1293011b9f8feee3f1e248c54f0bd281fa449abcde5e04c6e4016a3ee85bb32f7fe49f78cdcd8ada3183a5ede6960
+  data.tar.gz: a4b9d1916b46303d56bcc1dbb1272db560054d5012997c6794017b361ae5ea39f1ec07b2fb5c6d2305cbc94cc6ea17e0107e236566d63c14f786e7de3fd16dad

data/lib/core/lorj_basecontroller.rb

@@ -138,26 +138,46 @@ module Lorj
         controller_error "'%s' do not have 'each' function.", objects.class
       end
       objects.each do |o|
-        if [Proc, Method].include?(triggers[:before].class)
-          code = triggers[:before]
-          next unless code.call o
-        end
+        trig_ret = _run_trigger(triggers, :before, [TrueClass, FalseClass],
+                                true, o, query)
+        next unless trig_ret
         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
+        selected = _run_trigger(triggers, :after, [TrueClass, FalseClass],
+                                selected, o, query, selected)
         results.push o if selected
       end
       Lorj.debug(4, '%d records selected', results.length)
       results
     end
 
+    # Internal functions used by #ctrl_query_each to give control
+    # on the query feature.
+    def _run_trigger(triggers, name, expect, default, *p)
+      return default if triggers[name].nil?
+
+      code = triggers[name]
+      begin
+        trig_ret = code.call(*p)
+      rescue
+        Lorj.error("trigger '%s' '%s' is in error: \n%s",
+                   name, method_name, e)
+      end
+      method_name = "Unamed #{code.class}"
+      method_name = code.name if code.is_a?(Method)
+      if expect.length > 0 && !expect.include?(trig_ret.class)
+        PrcLib.warning("trigger '%s': Method '%s' should return one of '%s' ."\
+                       " It returns '%s'. Ignored.",
+                       name, method_name, expect, trig_ret.class)
+        return default
+      end
+      trig_ret
+    end
+
     # controller helper function:
     # Function to return match status
     # from a list of attributes regarding a query attribute list
@@ -193,8 +213,12 @@ module Lorj
     #     - Any object exception during data extraction.
     #
     def ctrl_do_query_match(object, query)
+      return true unless query.is_a?(Hash)
+
+      Lorj.debug(3, "'%s' selected by '%s'?", object.class, query)
       selected = true
       query.each do |key, match_value|
+        Lorj.debug(4, "'%s' match '%s'?", key, match_value)
         key_path = KeyPath.new(key)
         if block_given?
           found, v = _get_from(object, key_path.tree) { |d, k| yield d, k }
@@ -202,12 +226,17 @@ module Lorj
           found, v = _get_from(object, key_path.tree)
         end
 
-        Lorj.debug(4, "'%s.%s' = '%s'", object.class, key, v) if found
+        controller_error("'%s': '%s' not found", object.class, key) unless found
 
-        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)
+        Lorj.debug(4, "'%s.%s' = '%s'", object.class, key, v)
+
+        %w(regexp hash array default).each do |f|
+          t, s = method("lorj_filter_#{f}".to_sym).call v, match_value
+          next unless t
+          selected &= s
+          Lorj.debug(5, "Filter used '%s' returned '%s'", f, s)
+          break
+        end
         break unless selected
       end
       Lorj.debug(4, 'object selected.') if selected
@@ -221,7 +250,7 @@ module Lorj
 
     def _get_from(data, *key)
       ret = nil
-      found = nil
+      found = false
       key.flatten!
 
       if data.is_a?(Hash)
@@ -230,26 +259,29 @@ module Lorj
         return [found, ret]
       end
 
+      if block_given?
+        begin
+          Lorj.debug(4, "yield extract '%s' from '%s'", key, data.class)
+          return [true, yield(data, *key)]
+        rescue => e
+          PrcLib.error("yield extract '%s' from '%s' error  \n%s",
+                       key, object.class, e)
+        end
+        return [found, ret]
+      end
+
       [:[], 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?
-
-      begin
-        Lorj.debug(4, "yield extract '%s' from '%s'", key, object.class)
-        return [true, yield(data, key)]
-      rescue
-        PrcLib.error("yield extract '%s' from '%s' error  \n%s",
-                     key, object.class, e)
-      end
-      [false, nil]
+      [found, ret]
     end
 
     def _get_from_func(data, key, func = nil)
-      func = key[0] if func.nil?
+      func = key if func.nil?
       v = nil
+      found = false
       if data.class.method_defined?(func)
         begin
           found = true
@@ -269,50 +301,63 @@ module Lorj
       end
       [found, v]
     end
+
     # Function to check if a value match a regexp
     #
+    # * *args*:
+    #   - value      : The controller value to test matching.
+    #   - match_value: RegExp object to match against value.
+    #
     # * *returns*:
-    #   - true if the match is not a regexp, or if regexp match
-    # OR
-    #   - false otherwise
+    #   - treated: true if match_value is RegExp
+    #   - status : true if match. false otherwise
     #
-    def lorj_filter_regexp(value, match_value)
-      return false unless match_value.is_a?(Regexp)
+    def lorj_filter_regexp(value, match_value) # :doc:
+      return [false, false] unless match_value.is_a?(Regexp)
 
-      return true if match_value.match(value)
-      false
+      return [true, true] if match_value.match(value)
+      [true, false]
     end
 
-    # Function to check if a value is found in an Array
+    # Function to check if match_value is found in an Array.
+    #
+    # * *args*:
+    #   - value      : The controller value to test matching.
+    #   - match_value: The matching subhash match.
+    #     It can be an Array of match_value or just match_value
     #
     # * *returns*:
-    #   - true if found
-    # OR
-    #   - false otherwise
+    #   - treated: true if match_value is Array
+    #   - status : true if match. false otherwise
     #
-    def lorj_filter_array(value, match_value)
-      return false unless value.is_a?(Array) || match_value.is_a?(Array)
+    def lorj_filter_array(value, match_value) # :doc:
+      return [false, 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)
+        return [true, (match_value - value).empty?]
       end
 
-      value.include?(match_value)
+      [true, value.include?(match_value)]
     end
 
     # Function to check if a value match a filter value.
     #
+    # * *args*:
+    #   - value    : The controller value to test matching
+    #   - structure: The matching subhash match.
+    #     It will be interpreted by #Lorj::KeyPath.
+    #
     # * *returns*:
-    #   - true if match
-    # OR
-    #   - false otherwise
+    #   - treated: true if match_value is Hash
+    #   - status : true if match. false otherwise
     #
-    def lorj_filter_hash(value, structure)
-      return false unless value.is_a?(Hash)
+    def lorj_filter_hash(value, structure) # :doc:
+      return [false, false] unless value.is_a?(Hash)
 
       key_path = KeyPath.new(structure)
       tree = key_path.tree[0..-2]
-      return false unless value.rh_exist?(tree)
+      return [true, 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)
@@ -321,13 +366,16 @@ module Lorj
 
     # Function to check if a value match a filter value.
     #
+    # * *args*:
+    #   - value    : The controller value to test matching
+    #   - structure: The matching subhash match.
+    #
     # * *returns*:
-    #   - true if match
-    # OR
-    #   - false otherwise
+    #   - treated: true if match_value is Hash
+    #   - status : true if match. false otherwise
     #
-    def lorj_filter_default(value, match_value)
-      (value == match_value)
+    def lorj_filter_default(value, match_value) # :doc:
+      [true, (value == match_value)]
     end
   end
 end

data/lib/lorj/version.rb

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

data/lib/lorj.rb

@@ -71,6 +71,8 @@ module Lorj
   # * *Raises* :
   #   No exceptions
   def self::debug(iLevel, sMsg, *p)
+    PrcLib.core_level = 0 if PrcLib.core_level.nil?
+
     if iLevel <= PrcLib.core_level
       message = format('-%s- %s', iLevel, sMsg)
 

data/spec/40_lorj_ctrl_spec.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# To debug spec, depending on Ruby version, you may need to install
+# 1.8 => ruby-debug
+# 1.9 => debugger
+# 2.0+ => byebug
+# The right debugger should be installed by default by bundle
+# So, just call:
+#
+#     bundle
+#
+# Then set RSPEC_DEBUG=true, put a 'stop' where you want in the spec code
+# and start rspec or even rake spec.
+#
+#     RSPEC_DEBUG=true rake spec_local (or spec which includes docker spec)
+# OR
+#     RSPEC_DEBUG=true rspec -f doc --color spec/<file>_spec.rb
+#
+
+app_path = File.dirname(__FILE__)
+$LOAD_PATH << app_path unless $LOAD_PATH.include?(app_path)
+require 'spec_helper'
+
+describe 'Controller features' do
+  context 'internal filters' do
+    before(:all) do
+      # BaseControllerSpec
+      class BaseControllerSpec < Lorj::BaseController
+        def self.def_internal(name)
+          spec_name = 'spec_' + name
+
+          # To call the function identified internally with 'spec' prefix
+          define_method(spec_name) do |*p|
+            send(name, *p)
+          end
+        end
+
+        # Internal function to test.
+        def_internal 'lorj_filter_regexp'
+        def_internal 'lorj_filter_array'
+        def_internal 'lorj_filter_hash'
+        def_internal 'lorj_filter_default'
+      end
+      PrcLib.spec_cleanup
+      PrcLib.data_path = File.join(app_path, '..', 'lorj-spec', 'data')
+      @o = BaseControllerSpec.new
+    end
+
+    it 'lorj_filter_default(..., ...) is accepted'\
+       ' (treated = false)' do
+      expect(@o.spec_lorj_filter_default('', '')[0]).to equal(true)
+      expect(@o.spec_lorj_filter_default('', //)[0]).to equal(true)
+      expect(@o.spec_lorj_filter_default([], '')[0]).to equal(true)
+      expect(@o.spec_lorj_filter_default({}, '')[0]).to equal(true)
+    end
+
+    it "lorj_filter_default('test2', 'test') return [true, false]" do
+      expect(@o.spec_lorj_filter_default('test2',
+                                         'test')[1]).to equal(false)
+    end
+
+    it "lorj_filter_default('test', 'test') return [true, true]" do
+      expect(@o.spec_lorj_filter_default('test', 'test')[1]).to equal(true)
+    end
+
+    it "lorj_filter_regexp('test2', ... except Regexp) is not recognized"\
+       ' (treated = false)' do
+      expect(@o.spec_lorj_filter_regexp('', '')[0]).to equal(false)
+      expect(@o.spec_lorj_filter_regexp('', //)[0]).to equal(true)
+      expect(@o.spec_lorj_filter_regexp([], '')[0]).to equal(false)
+      expect(@o.spec_lorj_filter_regexp({}, '')[0]).to equal(false)
+    end
+
+    it "lorj_filter_regexp('test2', /toto/) not match" do
+      expect(@o.spec_lorj_filter_regexp('test2', /toto/)[1]).to equal(false)
+    end
+
+    it "lorj_filter_regexp('test2', /test/) match" do
+      expect(@o.spec_lorj_filter_regexp('test2', /test/)[1]).to equal(true)
+    end
+
+    it "lorj_filter_array(... except Array, '') is not recognized"\
+       ' (treated = false)' do
+      expect(@o.spec_lorj_filter_array('', '')[0]).to equal(false)
+      expect(@o.spec_lorj_filter_array('', //)[0]).to equal(false)
+      expect(@o.spec_lorj_filter_array([], '')[0]).to equal(true)
+      expect(@o.spec_lorj_filter_array({}, '')[0]).to equal(false)
+    end
+
+    it "lorj_filter_array(['test2', :toto], 'test') not match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       'test')[1]).to equal(false)
+    end
+
+    it "lorj_filter_array(['test2', :toto], 'test2') match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       'test2')[1]).to equal(true)
+    end
+
+    it "lorj_filter_array(['test2', :toto], []) match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       [])[1]).to eq(true)
+    end
+
+    it "lorj_filter_array(['test2', :toto], [:test]) not match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       [:test])[1]).to equal(false)
+    end
+
+    it "lorj_filter_array(['test2', :toto], [:test]) match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       [:toto])[1]).to equal(true)
+    end
+
+    it "lorj_filter_array(['test2', :toto], [:toto, 'test2']) match" do
+      expect(@o.spec_lorj_filter_array(['test2', :toto],
+                                       [:toto, 'test2'])[1]).to equal(true)
+    end
+
+    it "lorj_filter_hash(... except Hash, '') is not recognized "\
+       '(treated = false)' do
+      expect(@o.spec_lorj_filter_hash('', '')[0]).to equal(false)
+      expect(@o.spec_lorj_filter_hash('', //)[0]).to equal(false)
+      expect(@o.spec_lorj_filter_hash([], '')[0]).to equal(false)
+      expect(@o.spec_lorj_filter_hash({}, '')[0]).to equal(true)
+    end
+
+    it "lorj_filter_hash({:test => 'value'}, :test2) not match" do
+      data = { :test => 'value' }
+      expect(@o.spec_lorj_filter_hash(data, :test2)[1]).to equal(false)
+    end
+
+    it "lorj_filter_hash({:test => 'value'}, :test) not match" do
+      data = { :test => 'value' }
+      expect(@o.spec_lorj_filter_hash(data, :test)[1]).to equal(false)
+    end
+
+    it "lorj_filter_hash({:test => 'value'}, ':test/:toto') not match" do
+      data = { :test => 'value' }
+      expect(@o.spec_lorj_filter_hash(data, ':test/:toto')[1]).to equal(false)
+    end
+
+    it "lorj_filter_hash({:test => 'value'}, [:test, 'value']) not match" do
+      data = { :test => 'value' }
+      expect(@o.spec_lorj_filter_hash(data, [:test, 'value'])[1]).to equal(true)
+      expect(@o.spec_lorj_filter_hash(data, ':test/value')[1]).to equal(true)
+    end
+
+    it "lorj_filter_hash({:test => {:toto => 'value'}}, "\
+       "':test/:toto/value') match" do
+      data = { :test => { :toto => 'value' } }
+      expect(@o.spec_lorj_filter_hash(data,
+                                      ':test/:toto/value')[1]).to equal(true)
+      expect(@o.spec_lorj_filter_hash(data,
+                                      [:test, :toto,
+                                       'value'])[1]).to equal(true)
+    end
+  end
+  context 'Data extract' do
+    before(:all) do
+      # BaseControllerSpec
+      class BaseControllerSpec < Lorj::BaseController
+        def self.def_internal(name)
+          spec_name = 'spec_' + name
+
+          # To call the function identified internally with 'spec' prefix
+          define_method(spec_name) do |*p|
+            if p[-1].is_a?(Proc)
+              proc = p.pop
+              send(name, *p) { |*a| proc.call(*a) }
+            else
+              send(name, *p)
+            end
+          end
+        end
+
+        # Internal function to test.
+        def_internal 'ctrl_query_each'
+        def_internal '_run_trigger'
+        def_internal 'ctrl_do_query_match'
+        def_internal '_get_from'
+        def_internal '_get_from_func'
+      end
+
+      # TestData
+      class TestData
+        attr_accessor :attr1, :attr2
+
+        def initialize(attr1, attr2)
+          @attr1 = attr1
+          @attr2 = attr2
+        end
+
+        def all
+          { :attr1 => @attr1, :attr2 => @attr2 }
+        end
+      end
+      @o = BaseControllerSpec.new
+      @data = TestData.new('value1', 'value2')
+      @list = [@data, TestData.new('value3', 'value4'),
+               { :attr1 => 'value5', :attr2 => 'value6' },
+               { :attr1 => 'value7', :attr2 => 'value6' }]
+    end
+
+    it '_get_from_func(data) works' do
+      expect(@o.spec__get_from_func(@data, 'attr1')).to eq([true, 'value1'])
+      expect(@o.spec__get_from_func(@data, :attr1)).to eq([true, 'value1'])
+      expect(@o.spec__get_from_func(@data, :attr3)).to eq([false, nil])
+      expect(@o.spec__get_from_func(@data, :attr2)).to eq([true, 'value2'])
+      expect(@o.spec__get_from_func(@data, :'@attr2',
+                                    :instance_variable_get)
+            ).to eq([true, 'value2'])
+    end
+
+    it '_get_from(data, *key) works' do
+      expect(@o.spec__get_from(@data, :attr1)).to eq([true, 'value1'])
+      expect(@o.spec__get_from(@list[1], :attr1)).to eq([true, 'value3'])
+      # Uses [] internally
+      expect(@o.spec__get_from(@list[2], :attr1)).to eq([true, 'value5'])
+      expect(@o.spec__get_from(@data, :all, :attr1)).to eq([true, 'value1'])
+      expect(@o.spec__get_from(@data, :diff, lambda do |o, *k|
+        o.attr1 if k[0] == :diff
+      end)).to eq([true, 'value1'])
+    end
+
+    it 'ctrl_do_query_match works' do
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         {})).to equal(true)
+      expect do
+        @o.spec_ctrl_do_query_match(@data, :attr3 => '')
+      end.to raise_error(Lorj::PrcError)
+
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         :attr1 => 'value1')).to equal(true)
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         :attr1 => 'value1',
+                                         :attr2 => 'value3')).to equal(false)
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         :attr1 => 'value1',
+                                         :attr2 => /value$/)).to equal(false)
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         :attr1 => 'value1',
+                                         :attr2 => /value/)).to equal(true)
+      expect(@o.spec_ctrl_do_query_match(@data,
+                                         :attr1 => 'value1',
+                                         :attr2 => 'value2')).to equal(true)
+    end
+
+    it '_run_trigger works' do
+      def trigger1(*p)
+        p
+      end
+
+      def trigger2(*_p)
+        true
+      end
+      triggers = { :trig1 => method(:trigger1), :trig2 => method(:trigger2) }
+
+      expect(@o.spec__run_trigger({}, :blabla, [], nil)).to equal(nil)
+      expect(@o.spec__run_trigger({}, :blabla, [], true)).to equal(true)
+      expect(@o.spec__run_trigger(triggers, :blabla, [], nil)).to equal(nil)
+
+      expect(@o.spec__run_trigger(triggers, :trig1, [], nil,
+                                  'value1')).to eq(%w(value1))
+      expect(@o.spec__run_trigger(triggers, :trig1, [FalseClass], nil,
+                                  'value1')).to eq(nil)
+      expect(@o.spec__run_trigger(triggers, :trig2, [FalseClass, TrueClass],
+                                  nil, 'value1')).to eq(true)
+    end
+
+    it 'ctrl_query_each works' do
+      expect(@o.spec_ctrl_query_each(@list,
+                                     :attr1 => /value/,
+                                     :attr2 => 'value6').length).to eq(2)
+      expect(@o.spec_ctrl_query_each(@list,
+                                     :attr1 => 'value',
+                                     :attr2 => 'value6').length).to eq(0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -78,6 +78,17 @@ module Lorj
     end
   end
 
+  def show_log(lorj_debug = nil)
+    return unless ENV['RSPEC_DEBUG'] == 'true'
+
+    env_lorj_debug = ENV['LORJ_DEBUG']
+    if lorj_debug.nil? && env_lorj_debug && /[0-9]/ =~ env_lorj_debug
+      lorj_debug = ENV['LORJ_DEBUG'].to_i
+    end
+    PrcLib.core_level = lorj_debug unless lorj_debug.nil?
+    PrcLib.level = Logger::DEBUG
+  end
+
   def to_s
     a = {}
     instance_variables.each do |v|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lorj
 version: !ruby/object:Gem::Version
-  version: 1.0.17
+  version: 1.0.18
 platform: ruby
 authors:
 - forj team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-26 00:00:00.000000000 Z
+date: 2015-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -286,6 +286,7 @@ files:
 - spec/22_lorj_core_spec.rb
 - spec/30_lorj_basedefinition_spec.rb
 - spec/31_lorj_importexport_spec.rb
+- spec/40_lorj_ctrl_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/forj-oss/lorj
 licenses:
@@ -326,4 +327,5 @@ test_files:
 - spec/22_lorj_core_spec.rb
 - spec/30_lorj_basedefinition_spec.rb
 - spec/31_lorj_importexport_spec.rb
+- spec/40_lorj_ctrl_spec.rb
 - spec/spec_helper.rb