lorj 1.0.11 → 1.0.12

data/lib/core/lorj_baseprocess.rb

@@ -331,7 +331,7 @@ module Lorj
       list.each do |oElem|
         is_found = true
         sQuery.each do |key, value|
-          if oElem[key] != value
+          unless _qs_check_query_valid?(oElem, key, value)
             is_found = false
             break
           end
@@ -340,6 +340,20 @@ module Lorj
       end
     end
 
+    def _qs_check_query_valid?(elem, key, value)
+      if value.is_a?(Array)
+        path = value.clone
+        v = path.pop
+        return false if elem[key].nil?
+        where = elem[key].rh_get(path)
+        return true if where.is_a?(Array) && where.flatten.include?(v)
+        return true if where == v
+      else
+        return true if elem[key] == value
+      end
+      false
+    end
+
     def _qs_info_init(sInfoMsg)
       info = {
         :notfound => "No %s '%s' found",

data/lib/core/lorj_data.rb

@@ -12,6 +12,14 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
+file_dir = File.join(File.dirname(__FILE__), 'compat')
+compat_version = RUBY_VERSION[0..2]
+file = File.basename(__FILE__)
+
+lib = File.join(file_dir, compat_version, file)
+lib = File.join(file_dir, file) unless File.exist?(lib)
+load lib if File.exist?(lib)
+
 # - Lorj::Data : Defines how to manage Objects data between processes,
 #   controllers and internally in the core of Lorj.
 module Lorj
@@ -205,24 +213,6 @@ module Lorj
       get(*key)
     end
 
-    # Set Lorj::data attribute value for an :object
-    #
-    # * *Args* :
-    #   - +keys+ : attribute keys
-    #   - +value+: Value to set
-    #
-    # * *Returns* :
-    #   true
-    #
-    # * *Raises* :
-    #   No exceptions
-    #
-    def []=(*key, value)
-      return false if @type == :list
-      @data.rh_set(value, :attrs, key)
-      true
-    end
-
     # Get value from Lorj::data
     # Depending on Lorj::Data type, you can get:
     # - :object
@@ -482,6 +472,8 @@ module Lorj
       @is_registered = false
       self
     end
+
+    include Lorj::DataRubySpec::Public
   end
 
   #

data/lib/core/lorj_keypath.rb

@@ -49,6 +49,15 @@ module Lorj
   # puts oKey.tree      # => [:test,:test2,:test3]
   # puts oKey.key_tree  # => ':test/:test2/:test3'
   #
+  # 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.fpath     # => ':test/{\/.*\/}/:test3'
+  # puts oKey.tree      # => [:test, '{/.*/}',:test3]
+  # puts oKey.key_tree  # => ':test/{\/.*\/}/:test3'
+  #
   class KeyPath
     def initialize(sKeyPath = nil, max_level = -1)
       @keypath = []
@@ -83,22 +92,24 @@ module Lorj
 
     def fpath
       return nil if @keypath.length == 0
-      key_access = @keypath.clone
-      key_access.each_index do |iIndex|
-        next unless key_access[iIndex].is_a?(Symbol)
-        key_access[iIndex] = ':' + key_access[iIndex].to_s
+      akey = @keypath.clone
+      akey.each_index do |i|
+        akey[i] = akey[i].gsub(%r{/}, '\/') if akey[i].is_a?(String)
+        next unless akey[i].is_a?(Symbol)
+        akey[i] = ':' + akey[i].to_s
       end
-      key_access.join('/')
+      akey.join('/')
     end
 
     def to_s
       return nil if @keypath.length == 0
-      key_access = @keypath.clone
-      key_access.each_index do |iIndex|
-        next unless key_access[iIndex].is_a?(Symbol)
-        key_access[iIndex] = key_access[iIndex].to_s
+      akey = @keypath.clone
+      akey.each_index do |i|
+        akey[i] = akey[i].gsub(%r{/}, '\/') if akey[i].is_a?(String)
+        next unless akey[i].is_a?(Symbol)
+        akey[i] = akey[i].to_s
       end
-      key_access.join('/')
+      akey.join('/')
     end
 
     def key(iIndex = -1)
@@ -116,11 +127,21 @@ module Lorj
       # rubocop: disable Style/RegexpLiteral
       if %r{[^\\/]?/[^/]} =~ sKeyPath || %r{:[^:/]} =~ sKeyPath
         # rubocop: enable Style/RegexpLiteral
-        # keypath to interpret
-        res = sKeyPath.split('/')
+        res = []
+        # split then rejoin / prefixed by \
+        sKeyPath.split('/').each do |s|
+          if res[-1] && res[-1].match(/\\$/)
+            res[-1][-1] = ''
+            res[-1] += '/' + s
+          else
+            res << s
+          end
+        end
+
         res.each_index do |iIndex|
-          next unless res[iIndex].is_a?(String)
-          res[iIndex] = res[iIndex][1..-1].to_sym if res[iIndex][0] == ':'
+          # Ruby 1.8   : 'ab'[1] => 98 and 'ab'[1, 1] => 'b'
+          # Ruby 1.9 + : 'ab'[1] => 'b' and 'ab'[1, 1] => 'b'
+          res[iIndex] = res[iIndex][1..-1].to_sym if res[iIndex][0, 1] == ':'
         end
         @keypath = res
       else

data/lib/lorj/compat.rb

@@ -0,0 +1,99 @@
+# 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.
+
+# Ruby 1.8 case
+module Kernel
+  # Defined in ruby 1.9
+  unless defined?(__callee__)
+    def __callee__
+      caller[0] =~ /`([^']*)'/ && Regexp.last_match(1)
+    end
+  end
+end
+
+# Lorj Module Compatibility
+module Lorj
+  # BaseProcess Compatibility
+  class BaseProcess
+    # Adapt instance_methods
+    def self._instance_methods
+      # Ruby 1.8  : Object.instance_methods => Array of string
+      # Ruby 1.9+ : Object.instance_methods => Array of symbol
+      return instance_methods unless RUBY_VERSION.match(/1\.8/)
+
+      instance_methods.collect(&:to_sym)
+    end
+  end
+end
+
+# Redefine string representation of Array
+class Array
+  def to_s
+    '[' + map do |a|
+      if a.is_a?(String)
+        "\"#{a}\""
+      elsif a.is_a?(Symbol)
+        ":#{a}"
+      else
+        a.to_s
+      end
+    end.join(', ') + ']'
+  end
+end
+
+# Redefine string representation of Hash
+class Hash
+  def to_s
+    local = []
+    each do |a, b|
+      if a.is_a?(String)
+        k = "\"#{a}\""
+      elsif a.is_a?(Symbol)
+        k = ":#{a}"
+      else
+        k = a.to_s
+      end
+
+      if b.is_a?(String)
+        v = "\"#{b}\""
+      elsif b.is_a?(Symbol)
+        v = ":#{b}"
+      else
+        v = b.to_s
+      end
+      local << "#{k}=>#{v}"
+    end
+    '{' + local.join(', ') + '}'
+  end
+end
+
+# Support for encode 64 without \n
+module Base64
+  # Returns the Base64-encoded version of +bin+.
+  # This method complies with RFC 4648.
+  # No line feeds are added.
+  def strict_encode64(bin)
+    [bin].pack('m0')
+  end
+
+  # Returns the Base64-decoded version of +str+.
+  # This method complies with RFC 4648.
+  # ArgumentError is raised if +str+ is incorrectly padded or contains
+  # non-alphabet characters.  Note that CR or LF are also rejected.
+  def strict_decode64(str)
+    str.unpack('m0').first
+  end
+end

data/lib/lorj/version.rb

@@ -16,6 +16,6 @@
 
 # Lorj version
 module Lorj
-  VERSION = '1.0.11'
-  DATE = '2015-05-20'
+  VERSION = '1.0.12'
+  DATE = '2015-06-15'
 end

data/lib/lorj.rb

@@ -18,6 +18,7 @@
 #++
 
 require 'lorj/version'
+require 'lorj/compat' # Code introduced to support Ruby 1.8
 
 # This is the lorj base library.
 

data/lib/lorj_account.rb

@@ -63,6 +63,7 @@ module Lorj
   # This class limits ERB template to access only to config object data.
   class ERBConfig
     attr_reader :config
+    attr_accessor :data
 
     def initialize(config)
       @config = config

data/lib/lorj_defaults.rb

@@ -125,7 +125,7 @@ module Lorj
     end
 
     # Remove inherited method []=
-    def []=(*_keys, _value)
+    def []=(*_prop)
     end
 
     # Load yaml documents (defaults)

data/lib/lorj_meta.rb

@@ -18,6 +18,14 @@
 require 'rubygems'
 require 'yaml'
 
+file_dir = File.join(File.dirname(__FILE__), 'compat')
+compat_version = RUBY_VERSION[0..2]
+file = File.basename(__FILE__)
+
+lib = File.join(file_dir, compat_version, file)
+lib = File.join(file_dir, file) unless File.exist?(lib)
+load lib if File.exist?(lib)
+
 # Lorj module implements Lorj::Config
 # Lorj exposes defaults, as attribute to access the Lorj::Defaults instance.
 module Lorj
@@ -484,6 +492,11 @@ module Lorj
 
       arr = p_get(:keys => [:keys, data])
       return nil unless arr.is_a?(Array) && arr[0]
+      if /1\.8/ =~ RUBY_VERSION && arr.length > 1
+        PrcLib.warning('Avoid using Lorj::MetaAppConfig.first_section(%s) with'\
+                       ' Ruby 1.8 and searching for the first section as it do'\
+                       ' not preserve the order of Hash keys.', data)
+      end
       [arr[0], data]
     end
 
@@ -644,22 +657,6 @@ module Lorj
       p_set(:keys => keys, :name => layer, :value => options)
     end
 
-    # layer setting function
-    #
-    # * *Args*
-    #   - +type+    : :sections by default. Define the section type name.
-    #   - +section+ : Symbol. Section name of the data to define.
-    #   - +keys+    : 1 Symbol or more Symbols. Name of the data and options.
-    #   - +options+ : Hash. List of options
-    #
-    # * *Returns*
-    #   - The value set or nil
-    #
-    def []=(type, section, *keys, options)
-      return nil if keys.length == 0
-      set(type, section, keys, options)
-    end
-
     # section/data removal function
     #
     # * *Args*
@@ -741,6 +738,8 @@ module Lorj
 
       p_set(:keys => keys, :name => layer, :value => value.merge(options))
     end
+
+    include Lorj::MetaRubySpec::Public
   end
 
   module_function

data/lorj.gemspec

@@ -30,18 +30,23 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.1.0'
-  spec.add_development_dependency 'rubocop', '>= 0.29.0'
-  spec.add_development_dependency 'byebug' unless less_than_two
+  spec.add_development_dependency 'rdoc'
   spec.rdoc_options << \
     '--title Lorj - The Process Controllers framework system' << \
     '--main README.md'
 
-  spec.add_runtime_dependency 'config_layers', '~>0.1.3'
-  #  spec.add_runtime_dependency 'git', '>=1.2.7'
-  #  spec.add_runtime_dependency 'rbx-require-relative', '~>0.0.7'
+  spec.add_runtime_dependency 'config_layers', '~>0.1.4'
   spec.add_runtime_dependency 'highline', '~> 1.6.21'
   spec.add_runtime_dependency 'ansi', '>= 1.4.3'
-  #  spec.add_runtime_dependency 'bundler'
   spec.add_runtime_dependency 'encryptor', '1.3.0'
-  #  spec.add_runtime_dependency 'json', '1.7.5'
+  spec.add_runtime_dependency 'json'
+  if RUBY_VERSION.match(/1\.8/)
+    spec.add_development_dependency "ruby-debug"
+  elsif RUBY_VERSION.match(/1\.9/)
+    spec.add_development_dependency "debugger"
+    spec.add_development_dependency "rubocop", "~> 0.30.0"
+  else
+    spec.add_development_dependency "byebug"
+    spec.add_development_dependency "rubocop", "~> 0.30.0"
+  end
 end

data/spec/05_lorj_keypath_spec.rb

@@ -15,189 +15,230 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
-#    require 'byebug'
+require 'rubygems'
+require 'spec_helper'
 
 $LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib/core')
 
-require 'lorj_keypath'
+require 'lorj'
 
-describe 'Lorj::KeyPath,' do
-  context 'initialize with :test' do
+describe 'Lorj::KeyPath' do
+  context '.new(:test)' do
     before(:all) do
       @o_key = Lorj::KeyPath.new(:test)
     end
-    it 'Test method #length' do
+    it '#length return 1' do
       expect(@o_key.length).to eq(1)
     end
-    it 'Test method #to_s' do
+    it '#to_s return "test"' do
       expect(@o_key.to_s).to eq('test')
     end
-    it 'Test method #key' do
+    it '#key return :test' do
       expect(@o_key.key).to eq(:test)
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return :test' do
       expect(@o_key.key(0)).to eq(:test)
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return nil' do
       expect(@o_key.key(1)).to eq(nil)
     end
-    it 'Test method #fpath' do
+    it '#fpath return ":test"' do
       expect(@o_key.fpath).to eq(':test')
     end
-    it 'Test method #tree' do
+    it '#tree return :test' do
       expect(@o_key.key).to eq(:test)
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return :test' do
       expect(@o_key.key_tree).to eq(:test)
     end
   end
 
-  context 'initialize with [:test,:test2,:test3]' do
+  context '.new([:test,:test2,:test3])' do
     before(:all) do
       @o_key = Lorj::KeyPath.new([:test, :test2, :test3])
     end
-    it 'Test method #length' do
+    it '#length return 3' do
       expect(@o_key.length).to eq(3)
     end
-    it 'Test method #to_s' do
+    it '#to_s return "test/test2/test"' do
       expect(@o_key.to_s).to eq('test/test2/test3')
     end
-    it 'Test method #key' do
+    it '#key return :test3' do
       expect(@o_key.key).to eq(:test3)
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return :test' do
       expect(@o_key.key(0)).to eq(:test)
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return :test2' do
       expect(@o_key.key(1)).to eq(:test2)
     end
-    it 'Test method #fpath' do
+    it '#fpath return ":test/:test2/:test3"' do
       expect(@o_key.fpath).to eq(':test/:test2/:test3')
     end
-    it 'Test method #tree' do
+    it '#tree return [:test, :test2, :test3]' do
       expect(@o_key.tree).to eq([:test, :test2, :test3])
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return ":test/:test2/:test"' do
       expect(@o_key.key_tree).to eq(':test/:test2/:test3')
     end
   end
 
-  context 'initialize with string test1/test2' do
+  context '.new([:test, "/", :test3])' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new([:test, '/', :test3])
+    end
+    it '#length return 3' do
+      expect(@o_key.length).to eq(3)
+    end
+    it '#to_s return "test/\//test"' do
+      expect(@o_key.to_s).to eq('test/\//test3')
+    end
+    it '#key return :test3' do
+      expect(@o_key.key).to eq(:test3)
+    end
+    it '#key(0) return :test' do
+      expect(@o_key.key(0)).to eq(:test)
+    end
+    it '#key(1) return "/"' do
+      expect(@o_key.key(1)).to eq('/')
+    end
+    it '#fpath return ":test/\//:test3"' do
+      expect(@o_key.fpath).to eq(':test/\//:test3')
+    end
+    it '#tree return [:test, "/", :test3]' do
+      expect(@o_key.tree).to eq([:test, '/', :test3])
+    end
+    it '#key_tree return ":test/\//:test3"' do
+      expect(@o_key.key_tree).to eq(':test/\//:test3')
+    end
+  end
+
+  context '.new(":test/\//test3")' do
+    before(:all) do
+      @o_key = Lorj::KeyPath.new(':test/\//test3')
+    end
+    it 'is equivalent to .new([:test, "/", "test3"])' do
+      compare = Lorj::KeyPath.new([:test, '/', 'test3'])
+      expect(@o_key.tree).to eq(compare.tree)
+    end
+  end
+
+  context '.new("test1/test2")' do
     before(:all) do
       @o_key = Lorj::KeyPath.new('test1/test2')
     end
-    it 'Test method #length' do
+    it '#length return 2' do
       expect(@o_key.length).to eq(2)
     end
-    it 'Test method #to_s' do
+    it '#to_s return "test1/test2"' do
       expect(@o_key.to_s).to eq('test1/test2')
     end
-    it 'Test method #key' do
+    it '#key return "test2"' do
       expect(@o_key.key).to eq('test2')
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return "test"' do
       expect(@o_key.key(0)).to eq('test1')
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return "test2"' do
       expect(@o_key.key(1)).to eq('test2')
     end
-    it 'Test method #fpath' do
+    it '#fpath return "test1/test2"' do
       expect(@o_key.fpath).to eq('test1/test2')
     end
-    it 'Test method #tree' do
+    it '#tree return %w(test1 test2)' do
       expect(@o_key.tree).to eq(%w(test1 test2))
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return "test1/test2"' do
       expect(@o_key.key_tree).to eq('test1/test2')
     end
   end
 
-  context 'initialize with string :test' do
+  context '.new(":test")' do
     before(:all) do
       @o_key = Lorj::KeyPath.new(':test')
     end
-    it 'Test method #length' do
+    it '#length return 1' do
       expect(@o_key.length).to eq(1)
     end
-    it 'Test method #to_s' do
+    it '#to_s return "test"' do
       expect(@o_key.to_s).to eq('test')
     end
-    it 'Test method #key' do
+    it '#key return :test' do
       expect(@o_key.key).to eq(:test)
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return :test' do
       expect(@o_key.key(0)).to eq(:test)
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return nil' do
       expect(@o_key.key(1)).to eq(nil)
     end
-    it 'Test method #fpath' do
+    it '#fpath return ":test"' do
       expect(@o_key.fpath).to eq(':test')
     end
-    it 'Test method #tree' do
+    it '#tree return [:test]' do
       expect(@o_key.tree).to eq([:test])
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return :test' do
       expect(@o_key.key_tree).to eq(:test)
     end
   end
 
-  context 'initialize with string test' do
+  context '.new("test")' do
     before(:all) do
       @o_key = Lorj::KeyPath.new('test')
     end
-    it 'Test method #length' do
+    it '#length return 1' do
       expect(@o_key.length).to eq(1)
     end
-    it 'Test method #to_s' do
+    it '#to_s return "test"' do
       expect(@o_key.to_s).to eq('test')
     end
-    it 'Test method #key' do
+    it '#key return "test"' do
       expect(@o_key.key).to eq('test')
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return "test"' do
       expect(@o_key.key(0)).to eq('test')
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return nil' do
       expect(@o_key.key(1)).to eq(nil)
     end
-    it 'Test method #fpath' do
+    it '#fpath return "test"' do
       expect(@o_key.fpath).to eq('test')
     end
-    it 'Test method #tree' do
+    it '#tree return "test"' do
       expect(@o_key.tree).to eq(['test'])
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return "test"' do
       expect(@o_key.key_tree).to eq('test')
     end
   end
 
-  context 'initialize with nil' do
+  context '.new(nil)' do
     before(:all) do
       @o_key = Lorj::KeyPath.new(nil)
     end
-    it 'Test method #length' do
+    it '#length return 0' do
       expect(@o_key.length).to eq(0)
     end
-    it 'Test method #to_s' do
+    it '#to_s return nil' do
       expect(@o_key.to_s).to eq(nil)
     end
-    it 'Test method #key' do
+    it '#key return nil' do
       expect(@o_key.key).to eq(nil)
     end
-    it 'Test method #key(0)' do
+    it '#key(0) return nil' do
       expect(@o_key.key(0)).to eq(nil)
     end
-    it 'Test method #key(1)' do
+    it '#key(1) return nil' do
       expect(@o_key.key(1)).to eq(nil)
     end
-    it 'Test method #fpath' do
+    it '#fpath return nil' do
       expect(@o_key.fpath).to eq(nil)
     end
-    it 'Test method #tree' do
+    it '#tree return []' do
       expect(@o_key.tree).to eq([])
     end
-    it 'Test method #key_tree' do
+    it '#key_tree return nil' do
       expect(@o_key.key_tree).to eq(nil)
     end
   end