subhash 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b00b318ad28238acbf3a521efdc9bce58da2b91
-  data.tar.gz: 1602939ab1e875dc439ac412d5e00aebb4150a3c
+  metadata.gz: b002bfeab90a25d4208f184c8892ca90bd2a8761
+  data.tar.gz: df518060d1c2ae5f428b7eaa2302a6dd6cb8ba3e
 SHA512:
-  metadata.gz: 68ca39aa5a95e8aa9d2f763811233e123dd988d793f2fea28273b82d326ce0a1b8597be70ff07e4a47244aaf90e5bf6d7d77568558ad0f5895a6468dcb67af3b
-  data.tar.gz: 82d78c72c71aef00db56185adbb943c05253edc272eb7b03988f496722f8074ea21814052fe3ceef832d0fe8af8cfeff831041bd32a09301fd7eff360bbddfc0
+  metadata.gz: a183bffb2589c4f51b84de71436a2f562563e74b3a87f809471803303c490b9c005abc0320530c2c9f176c7f79bb0ed79e3fa3184e665b4699eeb237beeda106
+  data.tar.gz: 04f7c7a78f569b549a21f5b058109a2502b7225ae8f3976826de3b5c8d6f998259d8f8f4eedd3fc8ae9de8ba51bf2bc8dd33c38db0352d1a4e9b6dc9d89e99ca

data/Dockerfile

@@ -0,0 +1,19 @@
+FROM centos:6
+
+COPY files/proxy.sh /tmp/proxy.sh
+RUN /tmp/proxy.sh
+
+RUN yum -y install \
+  libffi-devel \
+  libxml2-devel \
+  libxslt-devel \
+  perl \
+  ruby \
+  rubygems \
+  ruby-devel \
+  ; yum -y groupinstall "Development tools" \
+  ; yum clean all
+
+RUN gem install --no-rdoc --no-ri bundler && rm -fr /root/.gem
+
+COPY files/bundle.sh /tmp/bundle.sh

data/Rakefile

@@ -1,12 +1,19 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-require 'rubocop/rake_task'
+require 'rubocop/rake_task' unless RUBY_VERSION.match(/1\.8/)
 require 'rdoc/task'
+require 'json'
 
 task :default => [:lint, :spec]
 
-desc 'Run the specs.'
-RSpec::Core::RakeTask.new do |t|
+desc 'Run all specs (locally + docker).'
+task :spec => [:spec_local, :spec18]
+
+desc 'Run acceptance test (docker - specs).'
+task :acceptance => [:spec18]
+
+desc 'Run the specs locally.'
+RSpec::Core::RakeTask.new(:spec_local) do |t|
   t.pattern = 'spec/*_spec.rb'
   t.rspec_opts = '-f doc'
 end
@@ -17,11 +24,41 @@ RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include('README.md', 'lib', 'example', 'bin')
 end
 
-desc 'Run RuboCop on the project'
-RuboCop::RakeTask.new(:lint) do |task|
-  task.formatters = ['progress']
-  task.verbose = true
-  task.fail_on_error = true
+if RUBY_VERSION.match(/1\.8/)
+  desc 'no lint with ruby 1.8'
+  task :lint
+else
+  desc 'Run RuboCop on the project'
+  RuboCop::RakeTask.new(:lint) do |task|
+    task.formatters = ['progress']
+    task.verbose = true
+    task.fail_on_error = true
+  end
+end
+
+# rubocop: disable Style/SpecialGlobalVars
+
+desc 'Run spec with docker for ruby 1.8'
+task :spec18 do
+  begin
+    `docker`
+  rescue
+    puts 'Unable to run spec against ruby 1.8: docker not found'
+  else
+    system('build/build_with_proxy.sh -t ruby/1.8')
+    image_id = `docker images ruby/1.8`.split("\n")[1].split[2]
+    res = `docker inspect -f '{{json .}}' subhash`
+    c_img = ''
+    c_img = JSON.parse(res)['Image'][0..11] if $?.exitstatus == 0
+
+    if $?.exitstatus == 0 && image_id == c_img
+      system('docker start -ai subhash')
+    else
+      `docker rm subhash` if $?.exitstatus == 0
+      system('docker run -it --name subhash -v $(pwd):/src -w /src ruby/1.8 '\
+             '/tmp/bundle.sh')
+    end
+  end
 end
 
 task :build => [:lint, :spec]

data/build/build_with_proxy.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+#
+# (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.
+
+function usage
+{
+ echo "usage is $0 [--help][-t user/repo:version]
+Script to build a docker image.
+It takes your local setting of $http_proxy to build the image with the same proxy
+If the proxy is not set, the docker image is simply executed, without proxy.
+
+Options :
+- help: is the current help
+- t   : Tag the image built. Respect the tag format use by docker -t option.
+"
+}
+
+if [ "p$1" = "p--help" ]
+then
+   usage
+   exit
+fi
+
+if [ "p$1" = "p-t" ] && [ "p$2" != "" ]
+then
+   TAG="-t $2"
+fi
+
+if [ "$http_proxy" = "" ]
+then
+   echo "Currently, no proxy is set. Running docker without proxy"
+   docker build $TAG
+   exit
+fi
+
+mkdir .tmp
+awk '$0 ~ /RUN \/tmp\/proxy.sh/ { print "ENV http_proxy '"$http_proxy"'" }
+     $0 ~ // { print $0 } ' Dockerfile > .tmp/Dockerfile
+cp -rp files tmp .tmp/
+docker build $TAG .tmp
+rm -fr .tmp

data/files/bundle.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+# (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.
+
+cd /src
+bundle
+rake spec_local

data/files/proxy.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+#
+# (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.
+
+if [ "$http_proxy" != "" ]
+then
+    echo "proxy setting to '$http_proxy'"
+    export http_proxy=$http_proxy
+    export https_proxy=$http_proxy
+    sed -i -e '/^\[main\]/aproxy='"$http_proxy" /etc/yum.conf
+fi

data/lib/iarray.rb

@@ -0,0 +1,365 @@
+# 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.
+
+# Defines rh_clone for Array
+class Array
+  # Recursive Hash deep level found counter
+  # See details from #Hash.rh_lexist?
+  def rh_lexist?(*p)
+    p = p.flatten
+
+    return 0 if p.length == 0
+
+    key = p[0]
+    sp = p.drop(1)
+
+    return _lexist_array(sp, key) if key.is_a?(Fixnum)
+
+    _loop_lexist_array(sp, key)
+  end
+
+  # Recursive Hash deep level existence
+  # See details at #Hash.rh_exist?
+  def rh_exist?(*p)
+    p = p.flatten
+
+    return nil if p.length == 0
+
+    count = p.length
+    (rh_lexist?(*p) == count)
+  end
+
+  # Recursive Hash Get
+  # Please look to #Hash::rh_get for details about this function.
+  def rh_get(*p)
+    p = p.flatten
+    return self if p.length == 0
+
+    key = p[0]
+    sp = p.drop(1)
+
+    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)
+
+    _loop_get_array(sp, key)
+  end
+
+  # return an exact clone of the recursive Array and Hash contents.
+  #
+  # * *Args*    :
+  #
+  # * *Returns* :
+  #   - Recursive Array/Hash cloned.
+  # * *Raises* :
+  #   Nothing
+  #
+  # examples:
+  #  hdata = { :test => { :test2 => { :test5 => :test,
+  #                                   'text' => 'blabla' },
+  #                       'test5' => 'test' },
+  #            :array => [{ :test => :value1 }, 2, { :test => :value3 }]}
+  #
+  #  hclone = hdata.rh_clone
+  #  hclone[:test] = "test"
+  #  hdata[:test] == { :test2 => { :test5 => :test,'text' => 'blabla' }
+  #  # => true
+  #  hclone[:array].pop
+  #  hdata[:array].length != hclone[:array].length
+  #  # => true
+  #  hclone[:array][0][:test] = "value2"
+  #  hdata[:array][0][:test] != hclone[:array][0][:test]
+  #  # => true
+  def rh_clone
+    result = []
+    each do |value|
+      begin
+        result << value.rh_clone
+      rescue
+        result << value
+      end
+    end
+    result
+  end
+
+  # This function is part of the rh_merge functionnality adapted for Array.
+  #
+  # To provide Array recursivity, we uses the element index.
+  #
+  # **Warning!** If the Array order has changed (sort/random) the index changed
+  # and can generate unwanted result.
+  #
+  # To implement recursivity, and some specific Array management (add/remove)
+  # you have to create an Hash and insert it at position 0 in the 'self' Array.
+  #
+  # **Warning!** If you create an Array, where index 0 contains a Hash, this
+  # Hash will be considered as the Array control element.
+  # If the first index of your Array is not a Hash, an empty Hash will be
+  # inserted at position 0.
+  #
+  # 'data' has the same restriction then 'self' about the first element.
+  # 'data' can influence the rh_merge Array behavior, by updating the first
+  # element.
+  #
+  # The first Hash element has the following attributes:
+  #
+  # - :__struct_changing: Array of index which accepts to move from a structured
+  #   data (Hash/Array) to another structure or type.
+  #
+  #   Ex: Hash => Array, Array => Integer
+  #
+  # - :__protected: Array of index which protects against update from 'data'
+  #
+  # - :__remove: Array of elements to remove. each element are remove with
+  #   Array.delete function. See Array delete function for details.
+  #
+  # - :__remove_index: Array of indexes to remove.
+  #   Each element are removed with Array.delete_at function.
+  #   It starts from the highest index until the lowest.
+  #   See Array delete function for details.
+  #
+  # **NOTE**: __remove and __remove_index cannot be used together.
+  #   if both are set, __remove is choosen
+  #
+  # **NOTE** : __remove* is executed before __add*
+  #
+  # - :__add: Array of elements to add. Those elements are systematically added
+  #   at the end of the Array. See Array.<< for details.
+  #
+  # - :__add_index: Hash of index(key) + Array of data(value) to add.
+  #   The index listed refer to merged 'self' Array. several elements with same
+  #   index are grouply inserted in the index.
+  #   ex:
+  #     [:data3].rh_merge({:__add_index => [0 => [:data1, :data2]]})
+  #     => [{}, :data1, :data2, :data3]
+  #
+  # **NOTE**: __add and __add_index cannot be used together.
+  #   if both are set, __add is choosen
+  #
+  # How merge is executed:
+  #
+  # Starting at index 0, each index of 'data' and 'self' are used to compare
+  # indexed data.
+  # - If 'data' index 0 has not an Hash, the 'self' index 0 is just skipped.
+  # - If 'data' index 0 has the 'control' Hash, the array will be updated
+  #   according to :__add and :__remove arrays.
+  #   when done, those attributes are removed
+  #
+  # - For all next index (1 => 'data'.length), data are compared
+  #
+  #   - If the 'data' length is >  than 'self' length
+  #     addtionnal indexed data are added to 'self'
+  #
+  #   - If index element exist in both 'data' and 'self',
+  #     'self' indexed data is updated/merged according to control.
+  #     'data' indexed data can use :unset to remove the data at this index
+  #     nil is also supported. But the index won't be removed. data will just
+  #     be set to nil
+  #
+  # when all Arrays elements are merged, rh_merge will:
+  # - remove 'self' elements containing ':unset'
+  #
+  # - merge 'self' data at index 0 with 'data' found index 0
+  #
+  def rh_merge(data)
+    _rh_merge(clone, data)
+  end
+
+  def rh_merge!(data)
+    _rh_merge(self, data)
+  end
+end
+
+# Defines structure feature for Array object.
+class Array
+  private
+
+  # Loop in array
+  def _loop_get_array(sp, key)
+    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)
+      end
+    end
+    return ret if ret.length > 0
+    nil
+  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)
+  end
+
+  def _lexist_array(sp, key)
+    return 0 unless key >= 0 && key < length
+    return 1 if sp.length == 0
+
+    1 + self[key].rh_lexist?(sp) if [Array, Hash].include?(self[key].class)
+  end
+
+  def _loop_lexist_array(sp, key)
+    ret = []
+    each do |e|
+      next unless e.is_a?(Hash)
+      next unless e.key?(key)
+
+      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
+    end
+    ret.length > 0 ? ret.max : 0
+  end
+
+  def _keys_match(re, res, sp, opts)
+    empty = false
+    empty = opts.include?('e') if opts
+
+    each do |e|
+      next unless e.is_a?(Hash)
+
+      _keys_match_hash(re, res, sp, e)
+    end
+    return res if empty || res.length > 0
+    nil
+  end
+
+  def _keys_match_hash(re, res, sp, e)
+    e.keys.sort.each do |k|
+      k_re = _key_to_s(k)
+      next unless re.match(k_re)
+
+      if sp.length == 0
+        _update_res(res, k, e[k])
+      else
+        v = e[k].rh_get(sp) if [Array, Hash].include?(e[k].class)
+
+        _update_res(res, k, v) unless v.nil?
+      end
+    end
+    res
+  end
+
+  def _rh_merge(result, data)
+    data = data.clone
+    data_control = _rh_merge_control(data)
+    result_control = _rh_merge_control(result)
+
+    _rh_do_control_merge(result_control, result, data_control, data)
+
+    (1..(data.length - 1)).each do |index|
+      _rh_do_array_merge(result, index, data)
+    end
+
+    (-(result.length - 1)..-1).each do |index|
+      result.delete_at(index.abs) if result[index.abs] == :unset
+    end
+
+    _rh_do_array_merge(result, 0, [data_control])
+    # Remove all control elements in tree of arrays
+    _rh_remove_control(result[0])
+
+    result
+  end
+
+  def _rh_do_array_merge(result, index, data)
+    return if _rh_merge_recursive(result, index, data)
+
+    return unless _rh_struct_changing_ok?(result, index, data)
+
+    return unless _rh_merge_ok?(result, index)
+
+    result[index] = data[index] unless data[index] == :kept
+  end
+
+  #  Get the control element. or create it if missing.
+  def _rh_merge_control(array)
+    unless array[0].is_a?(Hash)
+      array.insert(0, :__control => true)
+      return array[0]
+    end
+
+    _rh_control_tags.each do |prop|
+      if array[0].key?(prop)
+        array[0][:__control] = true
+        return array[0]
+      end
+    end
+
+    array.insert(0, :__control => true)
+
+    array[0]
+  end
+
+  # Do the merge according to :__add and :__remove
+  def _rh_do_control_merge(_result_control, result, data_control, _data)
+    if data_control[:__remove].is_a?(Array)
+      _rh_do_control_remove(result, data_control[:__remove])
+    elsif data_control[:__remove_index].is_a?(Array)
+      index_to_remove = data_control[:__remove_index].uniq.sort.reverse
+      _rh_do_control_remove_index(result, index_to_remove)
+    end
+
+    data_control.delete(:__remove)
+    data_control.delete(:__remove_index)
+
+    if data_control[:__add].is_a?(Array)
+      data_control[:__add].each { |element| result << element }
+    elsif data_control[:__add_index].is_a?(Hash)
+      _rh_do_control_add_index(result, data_control[:__add_index].sort)
+    end
+
+    data_control.delete(:__add)
+    data_control.delete(:__add_index)
+  end
+
+  def _rh_do_control_add_index(result, add_index)
+    add_index.reverse_each do |elements_to_insert|
+      next unless elements_to_insert.is_a?(Array) &&
+                  elements_to_insert[0].is_a?(Fixnum) &&
+                  elements_to_insert[1].is_a?(Array)
+
+      index = elements_to_insert[0] + 1
+      elements = elements_to_insert[1]
+
+      elements.reverse_each { |element| result.insert(index, element) }
+    end
+  end
+
+  # do the element removal.
+  def _rh_do_control_remove(result, remove)
+    remove.each { |element| result.delete(element) }
+  end
+
+  def _rh_do_control_remove_index(result, index_to_remove)
+    index_to_remove.each { |index| result.delete_at(index + 1) }
+  end
+
+  include Rh
+  include RhGet
+end