subhash 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b002bfeab90a25d4208f184c8892ca90bd2a8761
-  data.tar.gz: df518060d1c2ae5f428b7eaa2302a6dd6cb8ba3e
+  metadata.gz: 9f0a051059b11209331fa863d593e6e7d2b0714c
+  data.tar.gz: 989f14524b03c77768a03e8d30588548d477980a
 SHA512:
-  metadata.gz: a183bffb2589c4f51b84de71436a2f562563e74b3a87f809471803303c490b9c005abc0320530c2c9f176c7f79bb0ed79e3fa3184e665b4699eeb237beeda106
-  data.tar.gz: 04f7c7a78f569b549a21f5b058109a2502b7225ae8f3976826de3b5c8d6f998259d8f8f4eedd3fc8ae9de8ba51bf2bc8dd33c38db0352d1a4e9b6dc9d89e99ca
+  metadata.gz: db164809d9c9bdd2e6f0c68e6e74c995d4ceb845c03ca2eaeef5e3f26ca00fed1123f39c1dd098e1e1cb63f58a4bc664121c084845039993e8d754d0892e9b21
+  data.tar.gz: cdcbc82160fa22fb53d1beca45df9cc2e0c43fa899151d87b3d6ae5fa6b9b62a279ed74ef65a4332acad9b297c75a9b3fc37f93c66f2a768923062620e4a7544

data/.rubocop.yml

@@ -31,3 +31,6 @@ Metrics/ClassLength:
 # allow arguments to be longer than 15
 Metrics/AbcSize:
   Max: 40
+
+Metrics/CyclomaticComplexity:
+  Max: 7

data/build/build_with_proxy.sh

@@ -41,7 +41,7 @@ fi
 if [ "$http_proxy" = "" ]
 then
    echo "Currently, no proxy is set. Running docker without proxy"
-   docker build $TAG
+   docker build $TAG .
    exit
 fi
 

data/lib/iarray.rb

@@ -26,9 +26,12 @@ class Array
     key = p[0]
     sp = p.drop(1)
 
-    return _lexist_array(sp, key) if key.is_a?(Fixnum)
+    re, _, opts = _regexp(key)
+    return _keys_match_lexist(re, [], sp, opts) unless re.nil?
 
-    _loop_lexist_array(sp, key)
+    return _lexist_array(sp, key) if [Fixnum, Range].include?(key.class)
+
+    _loop_lexist_array(p, key)
   end
 
   # Recursive Hash deep level existence
@@ -54,9 +57,9 @@ class Array
     re, res, opts = _regexp(key)
     return _keys_match(re, res, sp, opts) unless re.nil?
 
-    return _get_array(sp, key) if key.is_a?(Fixnum)
+    return _get_array(sp, key) if [Fixnum, Range].include?(key.class)
 
-    _loop_get_array(sp, key)
+    _loop_get_array(key, p)
   end
 
   # return an exact clone of the recursive Array and Hash contents.
@@ -189,49 +192,78 @@ class Array
   private
 
   # Loop in array
-  def _loop_get_array(sp, key)
+  def _loop_get_array(key, p)
+    if key =~ /=\[[0-9]+\.\.[0-9]+\]/
+      found = /=\[([0-9]+)\.\.([0-9]+)\]/.match(key)
+      extract = Range.new(found[1].to_i, found[2].to_i)
+      sp = p.drop(1)
+    elsif key =~ /=\[[0-9]+\]/
+      extract = /=\[([0-9]+)\]/.match(key)[1].to_i
+      sp = p.drop(1)
+    else
+      sp = p.clone
+    end
+
+    ret = _loop_array(sp)
+
+    return ret[extract] unless extract.nil?
+    return ret if ret.length > 0
+    nil
+  end
+
+  def _loop_array(sp)
     ret = []
     each do |e|
-      next unless e.is_a?(Hash)
-      next unless e.key?(key)
-
       if sp.length == 0
-        ret << e[key]
-      else
-        ret << e[key].rh_get(sp) if [Array, Hash].include?(e[key].class)
+        ret << e
+        next
       end
+
+      next unless e.structured?
+      found = e.rh_get(*sp)
+      ret << found unless found.nil?
     end
-    return ret if ret.length > 0
-    nil
+    ret
   end
-
   # Index provided. return the value of the index.
   def _get_array(sp, key)
     return self[key] if sp.length == 0
 
-    self[key].rh_get(sp) if [Array, Hash].include?(self[key].class)
+    if key.is_a?(Range)
+      res = []
+      self[key].each do |k|
+        next unless k.structured?
+        res << k.rh_get(sp) if k.rh_exist?(sp)
+      end
+      res
+    else
+      self[key].rh_get(sp) if self[key].structured?
+    end
   end
 
+  # Check in existing Array, Fixnum and Range data.
   def _lexist_array(sp, key)
-    return 0 unless key >= 0 && key < length
+    return 0 if _key_out_of_array(key)
+
     return 1 if sp.length == 0
 
-    1 + self[key].rh_lexist?(sp) if [Array, Hash].include?(self[key].class)
+    1 + self[key].rh_lexist?(sp) if self[key].structured?
+  end
+
+  def _key_out_of_array(key)
+    return !(key >= 0 && key < length) if key.is_a?(Fixnum)
+
+    test = 0..(length - 1)
+    !(test.include?(key.first) && test.include?(key.last))
   end
 
-  def _loop_lexist_array(sp, key)
+  # Check under each array element to get result.
+  def _loop_lexist_array(p, _key)
     ret = []
     each do |e|
-      next unless e.is_a?(Hash)
-      next unless e.key?(key)
+      next unless e.structured?
 
-      if sp.length == 0
-        ret << 1
-      else
-        res = 1
-        res += e[key].rh_lexist?(sp) if [Array, Hash].include?(e[key].class)
-        ret << res
-      end
+      ret << e.rh_lexist?(*p)
     end
     ret.length > 0 ? ret.max : 0
   end
@@ -249,6 +281,27 @@ class Array
     nil
   end
 
+  def _keys_match_lexist(re, res, sp, _opts)
+    each do |e|
+      next unless e.is_a?(Hash)
+
+      _keys_match_lexist_hash(re, res, sp, e)
+    end
+    return res.max if res.length > 0
+    0
+  end
+
+  def _keys_match_lexist_hash(re, res, sp, e)
+    e.keys.sort.each do |k|
+      k_re = _key_to_s(k)
+      next unless re.match(k_re)
+
+      v = 1
+      v += e[k].rh_lexist?(sp) if sp.length > 0 && e[k].structured?
+      res << v
+    end
+  end
+
   def _keys_match_hash(re, res, sp, e)
     e.keys.sort.each do |k|
       k_re = _key_to_s(k)
@@ -257,13 +310,18 @@ class Array
       if sp.length == 0
         _update_res(res, k, e[k])
       else
-        v = e[k].rh_get(sp) if [Array, Hash].include?(e[k].class)
+        v = e[k].rh_get(sp) if e[k].structured?
 
         _update_res(res, k, v) unless v.nil?
       end
     end
     res
   end
+end
+
+# Internal function for merge.
+class Array
+  private
 
   def _rh_merge(result, data)
     data = data.clone

data/lib/ihash.rb

@@ -64,21 +64,31 @@ class Hash
   #
   #   # it is like searching for nothing...
   #   yVal.rh_lexist? => 0
-
+  #
+  # New features 0.1.3
+  #
   def rh_lexist?(*p)
     p = p.flatten
 
     return 0 if p.length == 0
 
-    if p.length == 1
-      return 1 if self.key?(p[0])
-      return 0
-    end
-    return 0 unless self.key?(p[0])
+    key = p[0]
+    sp = p.drop(1)
+
+    selected, key = _erb_select(key)
+    return 0 unless selected
+
+    key = _erb_extract(key)
+
+    re, _, opts = _regexp(key)
+    return _keys_match_lexist(re, [], sp, opts) unless re.nil?
+
+    return 0 unless self.key?(key)
+
+    return 1 if p.length == 1
+
     ret = 0
-    if [Hash, Array].include?(self[p[0]].class)
-      ret = self[p[0]].rh_lexist?(p.drop(1))
-    end
+    ret = self[key].rh_lexist?(*sp) if self[key].structured?
     1 + ret
   end
 
@@ -148,8 +158,8 @@ class Hash
   #     In the subhash structure, each hierachie tree level is a Hash or an
   #     Array.
   #
-  #     At a given level the top key will be interpreted as follow if the object
-  #     is:
+  #     At a given level the top key will be interpreted as follow and used as
+  #     data selection if the object is:
   #     - Hash:
   #       You can define key matching with Regexp or with a structured string:
   #       - Regexp or '/<Regexp>/' or '[<Regexp>]' :
@@ -200,7 +210,7 @@ class Hash
   #   data.rh_get => { :test => {:test2 => 'value1', :test3 => 'value2'},
   #                    :test4 => 'value3'}
   #
-  # New features:
+  # New features: 0.1.2
   #   data.rh_get(:test, /^test/)       # => []
   #   data.rh_get(:test, /^:test/)      # => ['value1', 'value2']
   #   data.rh_get(:test, /^:test.*/)    # => ['value1', 'value2']
@@ -230,6 +240,95 @@ class Hash
   #   data.rh_get(:arr2, 1, :test7)     # => 'value7'
   #   data.rh_get(:arr2, 0, :test7)     # => nil
   #
+  # New features: 0.1.3
+  #
+  #   Introduce ERB context rh_get/exist?/lexist? functions:
+  #     ERB can be used to select a subhash or extract a key.
+  #
+  #     - ERB Selection
+  #       The ERB selection is detected by a string containing
+  #       '<%= ... %>|something'
+  #       The ERB code must return a boolean or 'true' to consider the current
+  #       data context as queriable with a key.
+  #       'something' can be any key (string, symbol or even an ERB extraction)
+  #     - ERB Extraction
+  #       The ERB selection is detected by a string containing simply
+  #       '<%= ... %>'
+  #       The result of that ERB call should return a string which will become a
+  #       key to extract data from the current data context.
+  #
+  #       NOTE! ERB convert any symbol using to_s. If you need to get a key as a
+  #       symbol, you will to add : in front of the context string:
+  #
+  #       Ex:
+  #         RhContext.context = :test
+  #         data.rh_get('<%= context =>') # is equivalent to data.rh_get('test')
+  #
+  #         RhContext.context = ':test'
+  #         data.rh_get('<%= context =>') # is equivalent to data.rh_get(:test)
+  #
+  #     The ERB context by default contains:
+  #     - at least a 'data' attribute. It contains the current Hash/Array
+  #       level data in the data structure hierarchy.
+  #     - optionally a 'context' attribute. Contains any kind of data.
+  #       This is typically set before any call to rh_* functions.
+  #
+  #     you can introduce more data in the context, by creating a derived class
+  #     from RhContext.ERBConfig. This will ensure attribute data/context exist
+  #     in the context.
+  #     Ex:
+  #
+  #         class MyContext < RhContext::ERBConfig
+  #           attr_accessor :config # Added config in context
+  #         end
+  #
+  #         RhContext.erb = MyContext.new
+  #         RhContext.erb.config = my_config
+  #         data.rh_get(...)
+  #
+  #     data = YAML.parse("---
+  #     :test:
+  #       :test2: value1
+  #       :test3: value2
+  #     :test4: value3
+  #     :arr1: [ 4, value4]
+  #     :arr2:
+  #     - :test5: value5
+  #       :test6: value6
+  #     - :test7: value7
+  #       :test8
+  #       :test5: value8
+  #     - :test5: value9")
+  #
+  #     # Default context:
+  #     RhContext.erb = nil
+  #     # Filtering using |
+  #     data.rh_get(:arr2, '<%= data.key?(:test8) %>|:test5')
+  #       # => ['value8']
+  #     RhContext.context = :test6
+  #     data.rh_get(:arr2, '<%= context %>')
+  #       # => ['value6']
+  #
+  #   Introduce Array extraction (Fixnum and Range)
+  #   When a data at a current level is an Array, get/exist?/lexist? interpret
+  #   - the string '=[<Fixnum|Range>]' where
+  #     - Fixnum : From found result, return the content of result[<Fixnum>]
+  #       => subhash data found. It can return nil
+  #     - Range : From found result, return the Range context of result[<Range>]
+  #       => Array of (subhash data found)
+  #    - the Range. complete the Array index selection.
+  #      ex: [:test1, {:test2 => :value1}].rh_get(0..1, :test2)
+  #
+  #     # data extraction. By default:
+  #     # data.rh_get(:arr2, :test5) return ['value5', 'value8', 'value9']
+  #     # then
+  #     data.rh_get(:arr2, '=[0]', :test5)    # => 'value5'
+  #     data.rh_get(:arr2, '=[0..1]', :test5) # => ['value5', 'value8']
+  #     data.rh_get(:arr2, '=[0..3]', :test5) # => ['value5', 'value8','value9']
+  #
+  #     # Data selection:
+  #     data.rh_get(:arr2, 0..1, :test5)      # => ['value5', 'value8']
+  #     data.rh_get(:arr2, 1..2, :test5)      # => ['value8', 'value9']
   def rh_get(*p)
     p = p.flatten
     return self if p.length == 0
@@ -237,6 +336,11 @@ class Hash
     key = p[0]
     sp = p.drop(1)
 
+    selected, key = _erb_select(key)
+    return nil unless selected
+
+    key = _erb_extract(key)
+
     re, res, opts = _regexp(key)
     return _keys_match(re, res, sp, opts) unless re.nil?
 
@@ -245,7 +349,7 @@ class Hash
       return nil
     end
 
-    return self[key].rh_get(sp) if [Array, Hash].include?(self[key].class)
+    return self[key].rh_get(*sp) if [Array, Hash].include?(self[key].class)
     nil
   end
 
@@ -505,6 +609,26 @@ end
 class Hash
   private
 
+  def _keys_match_lexist(re, res, sp, _opts)
+    _keys_match_loop_lexist(re, res, sp)
+
+    return 1 + res.max if res.length > 0
+    0
+  end
+
+  def _keys_match_loop_lexist(re, res, sp)
+    keys.sort.each do |k|
+      k_re = _key_to_s(k)
+      next unless re.match(k_re)
+
+      if sp.length == 0
+        res << 1
+      else
+        res << self[k].rh_lexist?(sp) if [Array, Hash].include?(self[k].class)
+      end
+    end
+  end
+
   def _keys_match(re, res, sp, opts)
     empty = false
     empty = opts.include?('e') if opts

data/lib/rh.rb

@@ -14,6 +14,48 @@
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
 
+# Recursive Hash context
+module RhContext
+  # Module attributes
+  class << self
+    attr_accessor :erb
+  end
+
+  # ERBConfig context for subhash selection, or filter
+  class ERBConfig
+    attr_accessor :data
+    attr_accessor :context
+
+    # Bind this limited class with ERB templates
+    def get_binding # rubocop: disable AccessorMethodName
+      binding
+    end
+  end
+
+  module_function
+
+  def get(str)
+    return str if @erb.nil?
+    ERB.new(str).result(@erb.get_binding)
+  end
+
+  def data=(data)
+    @erb = ERBConfig.new if @erb.nil?
+
+    @erb.data = data
+  rescue
+    return
+  end
+
+  def context=(data)
+    @erb = ERBConfig.new if @erb.nil?
+
+    @erb.context = data
+  rescue
+    return
+  end
+end
+
 # Rh common module included in Hash and Array class.
 module Rh
   public
@@ -26,8 +68,39 @@ module Rh
     _rh_remove_control(rh_clone)
   end
 
+  def structured?
+    true
+  end
+
   private
 
+  # Return the erb call return
+  # true otherwise ie Selected by default.
+  def _erb_select(key)
+    return true, key unless key.is_a?(String) && key =~ /^<%=.*%>\|/
+    RhContext.data = self
+
+    found = /^(<%=.*%>)\|/.match(key)
+    key = key.clone
+    key[found[0]] = ''
+    [RhContext.get(found[1]) == 'true', _convert_key(key)]
+  end
+
+  def _erb_extract(key)
+    return key unless key.is_a?(String) && key =~ /^<%=.*%>[^|]?/
+    RhContext.data = self
+
+    _convert_key(RhContext.get(key))
+  end
+
+  def _convert_key(key)
+    return key unless key.is_a?(String)
+    # Ruby 1.8   : 'ab'[1] => 98 and 'ab'[1, 1] => 'b'
+    # Ruby 1.9+  : 'ab'[1] => 'b' and 'ab'[1, 1] => 'b'
+    return key[1..-1].to_sym if key[0, 1] == ':'
+    key
+  end
+
   # Function which will parse arrays in hierarchie and will remove any control
   # element (index 0)
   def _rh_remove_control(result)
@@ -155,3 +228,10 @@ module RhGet
     res[k] = v if res.is_a?(Hash)
   end
 end
+
+# By default all object are considered as unstructured, ie not Hash or Array.
+class Object
+  def structured?
+    false
+  end
+end

data/lib/subhash/version.rb

@@ -1,5 +1,5 @@
 # Recursive Hash
 module SubHash
-  VERSION = '0.1.2'
-  DATE = '2015-06-03'
+  VERSION = '0.1.3'
+  DATE = '2015-06-15'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: subhash
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Christophe Larsonneur
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-03 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler