nugrant 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36479d2a076b5dfd5f938969edcdc48f12ea9501
-  data.tar.gz: 162d0feefe4e742beeef2561187335ef313d79cd
+  metadata.gz: 59d03f3a6d570c597abc17133e4d68782e455cc0
+  data.tar.gz: f0d3558fa09f660559cbdd283d84b2b845a16d69
 SHA512:
-  metadata.gz: 0b5d3e769d89e6f527b39aa90696c19c1425a4058c08378dc89f6da33927599d1ce2566b883a012c185c6559b99575abe64863b2b9cf339752cbf72272284841
-  data.tar.gz: 96f6cb2405b5ea6a8a501662f3c36e78d6d9285fbf4b28ba834fff8fa9e7f22ce878cf96c5b4d194fd565ccd6d00c7583c4e97b482409502c4c84c4f4df54b3e
+  metadata.gz: 7f85374f9ff849c110f185558d2594355c5636037472ec278697b544aa5ee0ed1c7c0d869cb43f42d6d78895388444407fe2037e1e7c4d33586deb545c132ccb
+  data.tar.gz: 22761919a1b509bef418fd2993641d7f2b7d43ae9807bd58bd2d278af43a632665812a28236717c3f7c53bbcfbc25cc1514380d73bb0ba7ab6d67f415d4d9db0

data/CHANGELOG.md

@@ -1,9 +1,17 @@
+# 2.1.2 (January 12th, 2015)
+
+ * Fixed indifferent access inside arrays. Array elements of type `Hash`
+   are now converted to `Bag` instances (recursively). This fix the
+   indifferent access of `Bag` elements inside arrays.
+
+   Fixes [issue #27](https://github.com/maoueh/nugrant/issues/27).
+
 # 2.1.1 (December 2nd, 2014)
 
  * Permit numeric keys in bag. They are converted to symbol
    like others.
 
-   Fixes [issue #26](https://github.com/maoueh/nugrant/issues/26) again.
+   Fixes [issue #26](https://github.com/maoueh/nugrant/issues/26).
 
  * Removed old code that was switching YAML engine to `syck` when
    it was available.

data/lib/nugrant/bag.rb

@@ -142,7 +142,7 @@ module Nugrant
 
       Hash[map do |key, value|
         key = use_string_key ? key.to_s() : key
-        value = value.kind_of?(Bag) ? value.to_hash(options) : value
+        value = __convert_value_to_hash(value, options)
 
         [key, value]
       end]
@@ -178,11 +178,55 @@ module Nugrant
     # ensures at the same time a deeply preventive copy since a new
     # instance is created for this nested structure.
     #
+    # In addition, it also transforms array elements of type Hash into
+    # Bag instance also. This enable indifferent access inside arrays
+    # also.
+    #
     # @param value The value to convert to bag if necessary
     # @return The converted value
     #
     def __convert_value(value)
-      value.kind_of?(Hash) ? Bag.new(value, @__config) : value
+      case
+      # Converts Hash to Bag instance
+      when value.kind_of?(Hash)
+        Bag.new(value, @__config)
+
+      # Converts Array elements to Bag instances if needed
+      when value.kind_of?(Array)
+        value.map(&self.method(:__convert_value))
+
+      # Keeps as-is other elements
+      else
+        value
+      end
+    end
+
+    ##
+    # This function does the reversion of value conversion to Bag
+    # instances. It transforms Bag instances to Hash (using to_hash)
+    # and array Bag elements to Hash (using to_hash).
+    #
+    # The options parameters are pass to the to_hash function
+    # when invoked.
+    #
+    # @param value The value to convert to hash
+    # @param options The options passed to the to_hash function
+    # @return The converted value
+    #
+    def __convert_value_to_hash(value, options = {})
+      case
+      # Converts Bag instance to Hash
+      when value.kind_of?(Bag)
+        value.to_hash(options)
+
+      # Converts Array elements to Hash instances if needed
+      when value.kind_of?(Array)
+        value.map { |value| __convert_value_to_hash(value, options) }
+
+      # Keeps as-is other elements
+      else
+        value
+      end
     end
 
     def __get(key)

data/lib/nugrant/version.rb

@@ -1,3 +1,3 @@
 module Nugrant
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 end

data/test/lib/nugrant/test_bag.rb

@@ -5,39 +5,10 @@ require 'nugrant/helper/bag'
 
 module Nugrant
   class TestBag < ::Minitest::Test
-    def create_bag(elements, options = {})
-      return Bag.new(elements, options)
-    end
-
-    def assert_all_access_equal(expected, bag, key)
-      assert_equal(expected, bag.method_missing(key.to_sym), "bag.#{key.to_sym}")
-      assert_equal(expected, bag[key.to_s], "bag[#{key.to_s}]")
-      assert_equal(expected, bag[key.to_sym], "bag[#{key.to_sym}]")
-    end
-
-    def assert_all_access_bag(expected, bag, key)
-      assert_bag(expected, bag.method_missing(key.to_sym))
-      assert_bag(expected, bag[key.to_s])
-      assert_bag(expected, bag[key.to_sym])
-    end
-
-    def assert_bag(expected, bag)
-      assert_kind_of(Bag, bag)
-
-      expected.each do |key, expected_value|
-        if not expected_value.kind_of?(Hash)
-          assert_all_access_equal(expected_value, bag, key)
-          next
-        end
-
-        assert_all_access_bag(expected_value, bag, key)
-      end
-    end
-
     def run_test_bag(parameters)
       bag = create_bag(parameters)
 
-      assert_bag(parameters, bag)
+      assert_bag_equal(parameters, bag)
     end
 
     def test_bag()
@@ -101,18 +72,46 @@ module Nugrant
     def test_to_hash()
       hash = create_bag({}).to_hash()
 
-      assert_kind_of(Hash, hash)
+      assert_is_hash_exclusive(hash)
       assert_equal({}, hash)
 
       hash = create_bag({"value" => {:one => "value", "two" => "value"}}).to_hash()
 
-      assert_kind_of(Hash, hash)
-      assert_kind_of(Hash, hash[:value])
+      assert_is_hash_exclusive(hash)
+      assert_is_hash_exclusive(hash[:value])
       assert_kind_of(String, hash[:value][:one])
       assert_kind_of(String, hash[:value][:two])
       assert_equal({:value => {:one => "value", :two => "value"}}, hash)
     end
 
+    def test_to_hash_array_with_bag()
+      hash = create_bag({:a => [{:b => "1", :c => [{"d" => "2"}]}]}).to_hash()
+
+      assert_is_hash_exclusive(hash)
+      assert_kind_of(Array, hash[:a])
+      assert_is_hash_exclusive(hash[:a][0])
+      assert_kind_of(String, hash[:a][0][:b])
+      assert_kind_of(Array, hash[:a][0][:c])
+      assert_is_hash_exclusive(hash[:a][0][:c][0])
+      assert_kind_of(String, hash[:a][0][:c][0][:d])
+
+      assert_equal({:a => [{:b => "1", :c => [{:d => "2"}]}]}, hash)
+    end
+
+    def test_to_hash_array_with_bag_string_key()
+      hash = create_bag({:a => [{:b => "1", :c => [{"d" => "2"}]}]}).to_hash(use_string_key: true)
+
+      assert_is_hash_exclusive(hash)
+      assert_kind_of(Array, hash["a"])
+      assert_is_hash_exclusive(hash["a"][0])
+      assert_kind_of(String, hash["a"][0]["b"])
+      assert_kind_of(Array, hash["a"][0]["c"])
+      assert_is_hash_exclusive(hash["a"][0]["c"][0])
+      assert_kind_of(String, hash["a"][0]["c"][0]["d"])
+
+      assert_equal({"a" => [{"b" => "1", "c" => [{"d" => "2"}]}]}, hash)
+    end
+
     def test_merge_array_replace()
       # Replace should be the default case
       bag1 = create_bag({"first" => [1, 2]})
@@ -168,16 +167,16 @@ module Nugrant
 
       assert_equal({:first => {:second => [3, 4]}, :third => "three"}, bag1.to_hash())
 
-      assert_all_access_equal({:second => [3, 4]}, bag1, :first)
-      assert_all_access_equal([3, 4], bag1["first"], :second)
+      assert_indifferent_access_equal({:second => [3, 4]}, bag1, :first)
+      assert_indifferent_access_equal([3, 4], bag1["first"], :second)
     end
 
     def test_set_a_slot_with_a_hash_keeps_indifferent_access
       bag1 = create_bag({})
       bag1["first"] = {:second => [1, 2]}
 
-      assert_all_access_equal({:second => [1, 2]}, bag1, :first)
-      assert_all_access_equal([1, 2], bag1["first"], :second)
+      assert_indifferent_access_equal({:second => [1, 2]}, bag1, :first)
+      assert_indifferent_access_equal([1, 2], bag1["first"], :second)
     end
 
     def test_nil_key()
@@ -217,7 +216,7 @@ module Nugrant
     def test_numeric_keys_converted_to_string
       bag1 = create_bag({1 => "value1"})
 
-      assert_all_access_equal("value1", bag1, :'1')
+      assert_indifferent_access_equal("value1", bag1, :'1')
     end
 
     def test_custom_key_error_handler
@@ -243,7 +242,7 @@ module Nugrant
         "Some value"
       end)
 
-      assert_all_access_equal("Some value", bag, :invalid_value)
+      assert_indifferent_access_equal("Some value", bag, :invalid_value)
     end
 
     def test_walk_bag
@@ -304,11 +303,11 @@ module Nugrant
 
       assert_equal(Nugrant::Bag, bag3.class)
 
-      assert_all_access_equal("value1", bag3['first'], :level1)
-      assert_all_access_equal("overriden2", bag3['first'], :level2)
-      assert_all_access_equal("value3", bag3['second'], :level1)
-      assert_all_access_equal("value4", bag3['second'], :level2)
-      assert_all_access_equal("overriden5", bag3, :third)
+      assert_indifferent_access_equal("value1", bag3['first'], :level1)
+      assert_indifferent_access_equal("overriden2", bag3['first'], :level2)
+      assert_indifferent_access_equal("value3", bag3['second'], :level1)
+      assert_indifferent_access_equal("value4", bag3['second'], :level2)
+      assert_indifferent_access_equal("overriden5", bag3, :third)
     end
 
     def test_merge!
@@ -342,11 +341,11 @@ module Nugrant
 
       assert_equal(Nugrant::Bag, bag3.class)
 
-      assert_all_access_equal("value1", bag3['first'], :level1)
-      assert_all_access_equal("overriden2", bag3['first'], :level2)
-      assert_all_access_equal("value3", bag3['second'], :level1)
-      assert_all_access_equal("value4", bag3['second'], :level2)
-      assert_all_access_equal("overriden5", bag3, :third)
+      assert_indifferent_access_equal("value1", bag3['first'], :level1)
+      assert_indifferent_access_equal("overriden2", bag3['first'], :level2)
+      assert_indifferent_access_equal("value3", bag3['second'], :level1)
+      assert_indifferent_access_equal("value4", bag3['second'], :level2)
+      assert_indifferent_access_equal("overriden5", bag3, :third)
     end
 
     def test_merge_hash()
@@ -389,5 +388,63 @@ module Nugrant
 
       assert_equal([1, 2, 3, 1, 2, 3], bag3['first'])
     end
+
+    def test_indifferent_access_in_array
+      bag = create_bag({:a => [{:b => 1, :c => [{"d" => 1}]}]})
+
+      assert_indifferent_access_equal(1, bag['a'][0]['c'][0], :d)
+    end
+
+    ## Helpers & Assertions
+
+    def create_bag(elements, options = {})
+      return Bag.new(elements, options)
+    end
+
+    def assert_is_hash_exclusive(input)
+      assert_equal(true, input.kind_of?(Hash), "#{input} should be a kind of Hash")
+      assert_equal(false, input.kind_of?(Bag), "#{input} should not be a kind of Bag")
+    end
+
+    def assert_indifferent_access_equal(expected, bag, key)
+      assert_symbol_access_equal(expected, bag, key)
+      assert_string_access_equal(expected, bag, key)
+    end
+
+    def assert_string_access_equal(expected, bag, key)
+      assert_equal(expected, bag[key.to_s], "bag[#{key.to_s}]")
+    end
+
+    def assert_symbol_access_equal(expected, bag, key)
+      assert_equal(expected, bag.method_missing(key.to_sym), "bag.#{key.to_sym}")
+      assert_equal(expected, bag[key.to_sym], "bag[#{key.to_sym}]")
+    end
+
+    def assert_indifferent_access_bag_equal(expected, bag, key)
+      assert_string_access_bag_equal(expected, bag, key)
+      assert_symbol_access_bag_equal(expected, bag, key)
+    end
+
+    def assert_string_access_bag_equal(expected, bag, key)
+      assert_bag_equal(expected, bag[key.to_s])
+    end
+
+    def assert_symbol_access_bag_equal(expected, bag, key)
+      assert_bag_equal(expected, bag.method_missing(key.to_sym))
+      assert_bag_equal(expected, bag[key.to_sym])
+    end
+
+    def assert_bag_equal(expected, bag)
+      assert_kind_of(Bag, bag)
+
+      expected.each do |key, expected_value|
+        if not expected_value.kind_of?(Hash)
+          assert_indifferent_access_equal(expected_value, bag, key)
+          next
+        end
+
+        assert_indifferent_access_bag_equal(expected_value, bag, key)
+      end
+    end
   end
 end

data/test/lib/nugrant/test_parameters.rb

@@ -10,51 +10,6 @@ module Nugrant
     @@FORMATS = [:json, :yaml]
     @@INVALID_PATH = "impossible_file_path.yamljson.impossible"
 
-    def create_parameters(format, current_filename, user_filename, system_filename, defaults = {}, options = {})
-      extension = case format
-        when :json
-          "json"
-        when :yml, :yaml
-          "yml"
-        else
-          raise ArgumentError, "Format [#{format}] is currently not supported"
-      end
-
-      resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{format}")
-
-      current_path = "#{resource_path}/#{current_filename}.#{extension}" if current_filename
-      user_path = "#{resource_path}/#{user_filename}.#{extension}" if user_filename
-      system_path = "#{resource_path}/#{system_filename}.#{extension}" if system_filename
-
-      return Nugrant::Parameters.new(defaults, {
-        :format => format,
-        :current_path => current_path,
-        :user_path => user_path,
-        :system_path => system_path,
-        :array_merge_strategy => options[:array_merge_strategy]
-      })
-    end
-
-    def assert_all_access_equal(expected, parameters, key)
-      assert_equal(expected, parameters.method_missing(key.to_sym), "parameters.#{key.to_s}")
-      assert_equal(expected, parameters[key.to_s], "parameters[#{key.to_s}]")
-      assert_equal(expected, parameters[key.to_sym], "parameters[#{key.to_sym}]")
-    end
-
-    def assert_level(parameters, results)
-      results.each do |key, value|
-        assert_all_access_equal(value, parameters, key)
-      end
-
-      assert_key_error(parameters, "0.0.0")
-    end
-
-    def assert_key_error(parameters, key)
-      assert_raises(KeyError) do
-        parameters[key]
-      end
-    end
-
     def test_params_level_1()
       formats.each do |format|
         parameters = create_parameters(format, "params_current_1", "params_user_1", "params_system_1")
@@ -425,6 +380,53 @@ module Nugrant
       assert_equal("value1", parameters.servers[:'1'])
     end
 
+    ## Helpers & Assertions
+
+    def create_parameters(format, current_filename, user_filename, system_filename, defaults = {}, options = {})
+      extension = case format
+        when :json
+          "json"
+        when :yml, :yaml
+          "yml"
+        else
+          raise ArgumentError, "Format [#{format}] is currently not supported"
+      end
+
+      resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{format}")
+
+      current_path = "#{resource_path}/#{current_filename}.#{extension}" if current_filename
+      user_path = "#{resource_path}/#{user_filename}.#{extension}" if user_filename
+      system_path = "#{resource_path}/#{system_filename}.#{extension}" if system_filename
+
+      return Nugrant::Parameters.new(defaults, {
+        :format => format,
+        :current_path => current_path,
+        :user_path => user_path,
+        :system_path => system_path,
+        :array_merge_strategy => options[:array_merge_strategy]
+      })
+    end
+
+    def assert_all_access_equal(expected, parameters, key)
+      assert_equal(expected, parameters.method_missing(key.to_sym), "parameters.#{key.to_s}")
+      assert_equal(expected, parameters[key.to_s], "parameters[#{key.to_s}]")
+      assert_equal(expected, parameters[key.to_sym], "parameters[#{key.to_sym}]")
+    end
+
+    def assert_level(parameters, results)
+      results.each do |key, value|
+        assert_all_access_equal(value, parameters, key)
+      end
+
+      assert_key_error(parameters, "0.0.0")
+    end
+
+    def assert_key_error(parameters, key)
+      assert_raises(KeyError) do
+        parameters[key]
+      end
+    end
+
     def formats()
       @@FORMATS
     end

data/test/resources/vagrantfiles/v2.bag_inside_array

@@ -0,0 +1,15 @@
+Vagrant.configure("2") do |config|
+  config.user.defaults = {
+    nodes: [
+      {ip: '192.168.100.10'},
+      {ip: '192.168.100.11'}
+    ]
+  }
+
+  config.user.nodes.each_with_index do |node, index|
+    puts "Node ##{index}, string: #{node['ip']}"
+    puts "Node ##{index}, symbol: #{node[:ip]}"
+    puts "Node ##{index}, method: #{node.ip}"
+    puts ""
+  end
+end

data/test/resources/vagrantfiles/v2.fake

@@ -2,14 +2,28 @@ Vagrant.configure("2") do |config|
   config.user.defaults = {
     'local' => {
         'first' => "value1",
-        'second' => "value2"
+    },
+    'array' => {
+      'level1' => [1, 2]
+    },
+    'application' => {
+      'users' => {
+        "joe" => {
+          :full => "Joe Plumber"
+        },
+        "jane" => {
+          :full => "Jane Cook"
+        },
+      }
     }
   }
 
-  config.user.local.each do |name, value|
-    puts "Parameters #{name}: #{value}"
+  config.user.application.users.each do |key, data|
+    puts "Key #{key}: #{data}"
   end
 
-  puts "User has local (symbol)" if config.user.has?(:local)
-  puts "User has local (string)" if config.user.has?("local")
+  config.user.array_merge_strategy = :concat
+  config.user.auto_export = [:autoenv, :script]
+
+  config.vm.box = "opscode_centos-7.0_x86-64"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nugrant
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Matthieu Vachon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-03 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
@@ -104,6 +104,7 @@ files:
 - test/resources/json/params_user_nil_values.json
 - test/resources/json/params_windows_eol.json
 - test/resources/vagrantfiles/v2.auto_export
+- test/resources/vagrantfiles/v2.bag_inside_array
 - test/resources/vagrantfiles/v2.defaults_mixed_string_symbols
 - test/resources/vagrantfiles/v2.defaults_null_values_in_vagrantuser
 - test/resources/vagrantfiles/v2.defaults_using_string