nugrant 2.0.0.pre2 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 969a898ed0ac4d45b6adc22f43304d80a61d3eda
-  data.tar.gz: a2f9140bab38bd74f9297cda110572d49c0f8425
+  metadata.gz: c0de10dfbe571d6be4e0c7a7c3fa3c7d4893fc88
+  data.tar.gz: 9fbec16a209341335a171f6fe57128b71bfa6e60
 SHA512:
-  metadata.gz: ba35c594059cb9c04fef4495e55ca55fddbdafe95041335cd6ddec5e4234d6c65150f6418d407fc3d9dad28cff383a7402c369d0c429f3541eed7c00c7ed7dfe
-  data.tar.gz: b5684cd172236eb57add8c9492fc8818b23707f813adbc2c9dc21ce951f5b8c4f949646e208a2acdb510f1ef53ea68ddb4491872f4af96fd530cacf2c38b03e1
+  metadata.gz: a7d7b102855c2af842e76eaa609b96b4a6b5316a4f8a05a956e5515b514024e356ff5b4afd23dc9a2fc25126998d90146626e018e29851ed1952721351259b41
+  data.tar.gz: 5c16317e800d0c725ae2f2544935de78da3cf994b1214032f4a0ddbf1ffc3b86ec84437a7e188f4864a230dd172b35809ac9d1afa2b0c666b52bc767704cedce

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # 2.0.0 (In progress)
 
+ * Fixed bad implementation of config class `::Vagrant.plugin("2", :config)`
+   where `merge` was not implemented and was causing errors. Now, all objects
+   (i.e. `Config`, `Bag` and `Parameters` implements `merge` and `merge!`
+   correctly).
+
 * Added possibility to change array merge strategy. This can
   be used in Vagrant by doing `config.user.array_merge_strategy = <strategy>`
   where valid strategies are:

data/Gemfile

@@ -1,13 +1,11 @@
 source 'https://rubygems.org'
 
 group :development do
-  gem "rake", "~> 10.1"
-  gem "minitest", "~> 5.2"
+  gem "rake", "~> 10.3"
+  gem "minitest", "~> 5.3"
   gem "minitest-reporters", "~> 1.0"
 
-  gem "win32console", :platforms => ['mswin', 'mingw', :'x64_mingw']
-
-  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git", :tag => "v1.5.1"
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git", :tag => "v1.6.2"
 end
 
 group :plugins do

data/README.md

@@ -20,7 +20,7 @@ Supported platforms:
  * Vagrant 1.x
  * Ruby 1.9.3+
 
-## Overview
+## Quick Start
 
 Using Nugrant as a plug-in provides an easy and hierarchical system to manage
 machine and user specific parameters.
@@ -65,13 +65,26 @@ The order is project `.vagrantuser` overrides `$HOME/.vagrantuser` overrides
 `$SYSTEM/.vagrantuser` where `$HOME` is the user's home directory and `$SYSTEM`
 is the platform dependent folder where system global parameters are set.
 
-We use it in our team to specify the various parameters required for
-Vagrant `chef-solo` provisioner by putting the a `.vagrantuser` in our
-home directory under a key `chef`. It gets merged with the project's
-`.vagrantuser` file (if it exists), so it they can be overridden there.
+Use the command `vagrant user parameters` to see the final merged hierarchy
+seen by Nugrant. This command also prints [restricted keys](#restricted-keys) defined
+in your hierarchy.
 
-Please refer to section [Usage](#usage) for all details and explanations
-needed to fully use and understand Nugrant.
+You can access parameters in your `Vagrantfile` either by method access
+(i.e. `config.user.<key>`) or by array access (i.e. `config.user[<key>]`).
+This support is working for any deepness, only `config.user` is different
+because provided directly by `Vagrant` and not by this plugin.
+
+However, a drawback with method access, not present with array access, is its
+set of [restricted keys](#restricted-keys) for which usage is prohibited. These
+are in facts calls to method defined by the [Bag](lib/nugrant/bag.rb) class
+([Bag](lib/nugrant/bag.rb) extends [Hash](http://ruby-doc.org/core-2.0/Hash.html)).
+It's plain Ruby, use it at your advantage like iterating through a collection
+using the `.each` method.
+
+This is where the quick start end. Continue to section [Installation](#installation)
+if you need so help on how to install Nugrant. Or jump to [Usage](#usage) section
+which describe in greater details all necessary information needed to deeply
+understand Nugrant and use it at its full potential.
 
 ## Installation
 
@@ -274,9 +287,14 @@ is not provided by this plug-in but by Vagrant itself.
 
 Each non-final parameter (i.e a parameter that contains other parameters and
 not a scalar value) is in fact a [Bag](/lib/nugrant/bag.rb)
-object. You can call any defined methods on it. Since this object is also
-[Enumerable](http://ruby-doc.org/core-2.0/Enumerable.html), you can do neat things
-like iterating over your values or filtering them.
+object. You can call any defined methods on it. This object extends
+[Hash](http://ruby-doc.org/core-2.0/Hash.html) (itself including
+module [Enumerable](http://ruby-doc.org/core-2.0/Enumerable.html)). Hence,
+you can do neat things like iterating over your values or filtering them:
+
+    config.user.application.users.each do |key, data|
+      puts "Key #{key}: #{data}"
+    end
 
 ##### Restricted keys
 
@@ -333,8 +351,11 @@ As stated previously, when two arrays are merged together,
 the default strategy is to replace current array with new one.
 
 However, in some certain circumstances, you may need another
-behavior. That is why we also provide two other strategies
-that can be used.
+behavior. Here the list of strategies that can be used.
+
+ * `:replace` (*default*)
+   With this strategy, the new array completely replace the
+   current one.
 
  * `:concat`
    With this strategy, new array is appended to the end
@@ -355,6 +376,10 @@ to change the array merge strategy:
       config.ssh.port config.user.vm.ssh_port
     end
 
+Note that you should change the array merge strategy before
+you access any keys because it's just once set that values
+are computed using the new strategy.
+
 If you specify an unsupported strategy, nothing will happen.
 
 #### Commands

data/lib/nugrant/bag.rb

@@ -1,3 +1,5 @@
+require 'nugrant/config'
+
 module Nugrant
   class Bag < Hash
 
@@ -27,14 +29,30 @@ module Nugrant
       @__config = Config::convert(config)
 
       (elements || {}).each do |key, value|
-        self[key] = value.kind_of?(Hash) ? Bag.new(value, config) : value
+        self[key] = value
       end
     end
 
+    def config=(config)
+      @__config = Config::convert(config)
+    end
+
     def method_missing(method, *args, &block)
       self[method]
     end
 
+    ##
+    ### Enumerable Overridden Methods (for string & symbol indifferent access)
+    ##
+
+    def count(item)
+      super(__try_convert_item(item))
+    end
+
+    def find_index(item = nil, &block)
+      block_given? ? super(&block) : super(__try_convert_item(item))
+    end
+
     ##
     ### Hash Overridden Methods (for string & symbol indifferent access)
     ##
@@ -47,34 +65,74 @@ module Nugrant
     end
 
     def []=(input, value)
-      super(__convert_key(input), value)
+      super(__convert_key(input), __convert_value(value))
+    end
+
+    def assoc(key)
+      super(__convert_key(key))
+    end
+
+    def delete(key)
+      super(__convert_key(key))
+    end
+
+    def fetch(key, default = nil)
+      super(__convert_key(key), default)
+    end
+
+    def has_key?(key)
+      super(__convert_key(key))
+    end
+
+    def include?(item)
+      super(__try_convert_item(item))
     end
 
     def key?(key)
       super(__convert_key(key))
     end
 
-    ##
-    # This method deeply merge two instance together
-    #
-    #
-    def merge!(input)
-      input.each do |key, value|
+    def member?(item)
+      super(__try_convert_item(item))
+    end
+
+    def dup()
+      self.class.new(self, @__config.dup())
+    end
+
+    def merge(other, options = {})
+      result = dup()
+      result.merge!(other)
+    end
+
+    def merge!(other, options = {})
+      other.each do |key, value|
         current = __get(key)
         case
           when current == nil
             self[key] = value
 
           when current.kind_of?(Hash) && value.kind_of?(Hash)
-            current.merge!(value)
+            current.merge!(value, options)
 
           when current.kind_of?(Array) && value.kind_of?(Array)
-            self[key] = send("__#{@__config.array_merge_strategy}_array_merge", current, value)
+            strategy = options[:array_merge_strategy]
+            if not Nugrant::Config.supported_array_merge_strategy(strategy)
+              strategy = @__config.array_merge_strategy
+            end
+
+            self[key] = send("__#{strategy}_array_merge", current, value)
 
           when value != nil
             self[key] = value
         end
       end
+
+      self
+    end
+
+    def store(key, value)
+      self[key] = value
     end
 
     def to_hash(options = {})
@@ -90,9 +148,14 @@ module Nugrant
       end]
     end
 
-    ##
-    ### Aliases
-    ##
+    def walk(path = [], &block)
+      each do |key, value|
+        nested_bag = value.kind_of?(Nugrant::Bag)
+
+        value.walk(path + [key], &block) if nested_bag
+        yield path + [key], key, value if not nested_bag
+      end
+    end
 
     alias_method :to_ary, :to_a
 
@@ -108,13 +171,33 @@ module Nugrant
       raise ArgumentError, "Key cannot be converted to symbol, current value [#{key}] (#{key.class.name})"
     end
 
+    ##
+    # This function change value convertible to Bag into actual Bag.
+    # This trick enable deeply using all Bag functionalities and also
+    # ensures at the same time a deeply preventive copy since a new
+    # instance is created for this nested structure.
+    #
+    # @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
+    end
+
     def __get(key)
       # Calls Hash method [__convert_key(key)], used internally to retrieve value without raising Undefined parameter
       self.class.superclass.instance_method(:[]).bind(self).call(__convert_key(key))
     end
 
+    ##
+    # The concat order is the reversed compared to others
+    # because we assume that new values have precedence
+    # over current ones. Hence, the are prepended to
+    # current values. This is also logical for parameters
+    # because of the order in which bags are merged.
+    #
     def __concat_array_merge(current_array, new_array)
-      current_array + new_array
+      new_array + current_array
     end
 
     def __extend_array_merge(current_array, new_array)
@@ -124,5 +207,13 @@ module Nugrant
     def __replace_array_merge(current_array, new_array)
       new_array
     end
+
+    def __try_convert_item(args)
+      return [__convert_key(args[0]), args[1]] if args.kind_of?(Array)
+
+      __convert_key(args)
+    rescue
+      args
+    end
   end
 end

data/lib/nugrant/config.rb

@@ -125,6 +125,40 @@ module Nugrant
       validate()
     end
 
+    def ==(other)
+      self.class.equal?(other.class) &&
+      instance_variables.all? do |variable|
+        instance_variable_get(variable) == other.instance_variable_get(variable)
+      end
+    end
+
+    def [](key)
+      instance_variable_get("@#{key}")
+    rescue
+      nil
+    end
+
+    def merge(other)
+      result = dup()
+      result.merge!(other)
+    end
+
+    def merge!(other)
+      other.instance_variables.each do |variable|
+        instance_variable_set(variable, other.instance_variable_get(variable)) if instance_variables.include?(variable)
+      end
+
+      self
+    end
+
+    def to_h()
+      Hash[instance_variables.map do |variable|
+        [variable[1..-1].to_sym, instance_variable_get(variable)]
+      end]
+    end
+
+    alias_method :to_hash, :to_h
+
     def validate()
       raise ArgumentError,
         "Invalid value for :params_format. \

data/lib/nugrant/helper/env/exporter.rb

@@ -117,7 +117,7 @@ module Nugrant
         # @return (side-effect) Yields each key and value to a block
         #
         # Options:
-        #  * :namer => The namer used to transform bag segments into variable name, default to Namer::default().
+        #  * :namer => The namer used to transform bag parents into variable name, default to Namer::default().
         #  * :override => If true, variable a exported even when the override an existing env key, default to true.
         #
         def self.export(bag, options = {})
@@ -125,8 +125,8 @@ module Nugrant
           override = options.fetch(:override, true)
 
           variables = {}
-          walk_bag(bag) do |segments, key, value|
-            key = namer.call(segments)
+          bag.walk do |path, key, value|
+            key = namer.call(path)
 
             variables[key] = value if override or not ENV[key]
           end
@@ -189,19 +189,6 @@ module Nugrant
           # TODO: Handle platform differently
           "unset #{key}"
         end
-
-        # FIXME: Move this directly into bag class
-        def self.walk_bag(bag, parents = [], &block)
-          commands = []
-
-          bag.each do |key, value|
-            segments = parents + [key]
-            nested_bag = value.kind_of?(Nugrant::Bag)
-
-            walk_bag(value, segments, &block) if nested_bag
-            yield segments, key, value if not nested_bag
-          end
-        end
       end
     end
   end

data/lib/nugrant/mixin/parameters.rb

@@ -1,3 +1,7 @@
+require 'nugrant/bag'
+require 'nugrant/config'
+require 'nugrant/helper/bag'
+
 module Nugrant
   module Mixin
     ##
@@ -5,17 +9,32 @@ module Nugrant
     # logic between default Parameters class and Vagrant
     # implementation.
     #
-    # This method delegates method missing to the overall
-    # bag instance. This means that even if the class
+    # This module delegates method missing to the final
+    # bag hierarchy (@__all). This means that even if the class
     # including this module doesn't inherit Bag directly,
     # it act exactly like one.
     #
-    # To initialize the mixin module correctly, you must call
-    # the compute_bags! method at least once to initialize
-    # all variables. You should make this call in including
-    # class' constructor directly.
+    # When including this module, you must respect an important
+    # constraint.
+    #
+    # The including class must call `setup!` before starting using
+    # parameters retrieval. This is usually performed in
+    # the `initialize` method directly but could be in a different place
+    # depending on the including class lifecycle. The call to `setup!` is
+    # important to initialize all required instance variables.
+    #
+    # Here an example where `setup!` is called in constructor. Your constructor
+    # does not need to have these arguments, they are there as an example.
+    #
+    # ```
+    #     def initialize(defaults = {}, config = {}, options = {})
+    #       setup!(defaults, config, options)
+    #     end
+    # ```
     #
     module Parameters
+      attr_reader :__config, :__current, :__user, :__system, :__defaults, :__all
+
       def method_missing(method, *args, &block)
         case
         when @__all.class.method_defined?(method)
@@ -25,14 +44,14 @@ module Nugrant
         end
       end
 
-      def defaults()
-        @__defaults
-      end
-
       def array_merge_strategy
         @__config.array_merge_strategy
       end
 
+      ##
+      # Change the current array merge strategy for this parameters.
+      #
+      # @param strategy The new strategy to use.
       def array_merge_strategy=(strategy)
         return if not Nugrant::Config.supported_array_merge_strategy(strategy)
 
@@ -42,10 +61,14 @@ module Nugrant
         compute_all!()
       end
 
+      def defaults()
+        @__defaults
+      end
+
       ##
       # Set the new default values for the
       # various parameters contain by this instance.
-      # This will call __compute_all() to recompute
+      # This will call `compute_all!` to recompute
       # correct precedences.
       #
       # =| Attributes
@@ -58,6 +81,32 @@ module Nugrant
         compute_all!()
       end
 
+      def merge(other)
+        result = dup()
+        result.merge!(other)
+      end
+
+      def merge!(other)
+        @__config.merge!(other.__config)
+
+        # Updated Bags' config
+        @__current.config = @__config
+        @__user.config = @__config
+        @__system.config = @__config
+        @__defaults.config = @__config
+
+        # Merge other into Bags
+        @__current.merge!(other.__current, :array_merge_strategy => :replace)
+        @__user.merge!(other.__user, :array_merge_strategy => :replace)
+        @__system.merge!(other.__system, :array_merge_strategy => :replace)
+        @__defaults.merge!(other.__defaults, :array_merge_strategy => :replace)
+
+        # Recompute all from merged Bags
+        compute_all!()
+
+        self
+      end
+
       ##
       # Setup instance variables of the mixin. It will compute all parameters bags
       # (current, user, system, default and all) and stored them to these respective
@@ -75,19 +124,23 @@ module Nugrant
       #
       #  * `config`
       #    A Nugrant::Config object or hash passed to Nugrant::Config
-      #    constructor. Used to determine where to find the various
-      #    bag data sources.
+      #    convert method. Used to determine where to find the various
+      #    bag data sources and other configuration options.
       #
-      #    Passed to nested structures that require nugrant configuration
-      #    parameters like the Bag object and Helper::Bag module.
+      #    Passed to nested structures that requires a Nugrant::Config object
+      #    like the Bag object and Helper::Bag module.
       #
-      def setup!(defaults = {}, config = {})
+      #  * `options`
+      #    Options hash used by this method exclusively. No options yet, added
+      #    for future improvements.
+      #
+      def setup!(defaults = {}, config = {}, options = {})
         @__config = Nugrant::Config::convert(config);
 
+        @__defaults = Bag.new(defaults, @__config)
         @__current = Helper::Bag.read(@__config.current_path, @__config.params_format, @__config)
         @__user = Helper::Bag.read(@__config.user_path, @__config.params_format, @__config)
         @__system = Helper::Bag.read(@__config.system_path, @__config.params_format, @__config)
-        @__defaults = Bag.new(defaults, @__config)
 
         compute_all!()
       end

data/lib/nugrant/parameters.rb

@@ -1,10 +1,10 @@
-require 'nugrant/bag'
-require 'nugrant/config'
-require 'nugrant/helper/bag'
 require 'nugrant/mixin/parameters'
 
 module Nugrant
   class Parameters
+
+    include Mixin::Parameters
+
     ##
     # Create a new parameters object which holds completed
     # merged values. The following precedence is used to decide
@@ -14,14 +14,16 @@ module Nugrant
     #      project < user < system < defaults
     #
     # =| Arguments
+    #  * `defaults`
+    #    Passed to Mixin::Parameters setup! method. See mixin
+    #    module for further information.
+    #
     #  * `config`
-    #    Passed to Mixin::Parameters setup! method. See method
-    #    for further information.
+    #    Passed to Mixin::Parameters setup! method. See mixin
+    #    module for further information.
     #
-    def initialize(config)
-      setup!({}, config)
+    def initialize(defaults = {}, config = {}, options = {})
+      setup!(defaults, config, options)
     end
-
-    include Mixin::Parameters
   end
 end

data/lib/nugrant/vagrant/v2/command/env.rb

@@ -9,6 +9,10 @@ module Nugrant
     module V2
       module Command
         class Env < ::Vagrant.plugin("2", :command)
+          def self.synopsis
+            "env utilities to export config.user as environment variables in host machine"
+          end
+
           def initialize(arguments, environment)
             super(arguments, environment)
 
@@ -75,8 +79,12 @@ module Nugrant
 
             @logger.debug("Nugrant 'Env'")
             with_target_vms(arguments) do |vm|
-              config = vm.config.user
-              parameters = config ? config : Nugrant::Parameters.new()
+              parameters = vm.config.user
+              if not parameters
+                @env.ui.info("# Vm '#{vm.name}' : unable to retrieve `config.user`, report as bug https://github.com/maoueh/nugrant/issues", :prefix => false)
+                next
+              end
+
               bag = parameters.__all
 
               options = {:type => @unset ? :unset : :export}

data/lib/nugrant/vagrant/v2/command/parameters.rb

@@ -7,6 +7,10 @@ module Nugrant
     module V2
       module Command
         class Parameters < ::Vagrant.plugin("2", :command)
+          def self.synopsis
+            "prints parameters hierarchy as seen by Nugrant"
+          end
+
           def initialize(arguments, environment)
             super(arguments, environment)
 
@@ -61,8 +65,11 @@ module Nugrant
 
             @logger.debug("'Parameters' each target VM...")
             with_target_vms(arguments) do |vm|
-              config = vm.config.user
-              parameters = config || Nugrant::Parameters.new()
+              parameters = vm.config.user
+              if not parameters
+                @env.ui.info("# Vm '#{vm.name}' : unable to retrieve `config.user`, report as bug https://github.com/maoueh/nugrant/issues", :prefix => false)
+                next
+              end
 
               @env.ui.info("# Vm '#{vm.name}'", :prefix => false)
 
@@ -134,8 +141,8 @@ module Nugrant
 
           def print_warning(used_restricted_keys)
             @env.ui.info("", :prefix => false)
-            @env.ui.info(" You are using some restricted keys. Method access will not work with", :prefix => false)
-            @env.ui.info(" the following keys, only array access will:", :prefix => false)
+            @env.ui.info(" You are using some restricted keys. Method access (using .<key>) will", :prefix => false)
+            @env.ui.info(" not work, only array access ([<key>]) will. Offending keys:", :prefix => false)
             @env.ui.info("   #{used_restricted_keys.join(", ")}", :prefix => false)
             @env.ui.info("", :prefix => false)
           end

data/lib/nugrant/vagrant/v2/command/restricted_keys.rb

@@ -6,6 +6,10 @@ module Nugrant
     module V2
       module Command
         class RestrictedKeys < ::Vagrant.plugin("2", :command)
+          def self.synopsis
+            "prints list of restricted keys for method access"
+          end
+
           def initialize(arguments, environment)
             super(arguments, environment)
 

data/lib/nugrant/vagrant/v2/command/root.rb

@@ -9,6 +9,10 @@ module Nugrant
     module V2
       module Command
         class Root < ::Vagrant.plugin("2", :command)
+          def self.synopsis
+            "manage Nugrant user defined parameters (config.user)"
+          end
+
           def initialize(arguments, environment)
             super(arguments, environment)
 
@@ -36,7 +40,7 @@ module Nugrant
 
           def create_parser()
             return OptionParser.new do |parser|
-              parser.banner = "Usage: vagrant user [-h] [-v] <command> [<args>]"
+              parser.banner = "Usage: vagrant user [-h] [-v] <subcommand> [<args>]"
 
               parser.separator ""
               parser.on("-h", "--help", "Print this help") do
@@ -58,7 +62,7 @@ module Nugrant
               end
 
               parser.separator ""
-              parser.separator "For help on any individual command run `vagrant user COMMAND -h`"
+              parser.separator "For help on any individual command run `vagrant user <subcommand> -h`"
             end
           end
 

data/lib/nugrant/vagrant/v2/config/user.rb

@@ -1,4 +1,3 @@
-require 'nugrant'
 require 'nugrant/mixin/parameters'
 require 'nugrant/vagrant/errors'
 
@@ -7,10 +6,11 @@ module Nugrant
     module V2
       module Config
         class User < ::Vagrant.plugin("2", :config)
-          attr_reader :__current, :__user, :__system, :__defaults, :__all
 
-          def initialize()
-            setup!({},
+          include Mixin::Parameters
+
+          def initialize(defaults = {}, config = {})
+            setup!(defaults,
               :params_filename => ".vagrantuser",
               :key_error => Proc.new do |key|
                 raise Errors::ParameterNotFoundError, :key => key.to_s
@@ -21,7 +21,7 @@ module Nugrant
             )
           end
 
-          include Mixin::Parameters
+
         end
       end
     end

data/lib/nugrant/version.rb

@@ -1,3 +1,3 @@
 module Nugrant
-  VERSION = "2.0.0.pre2"
+  VERSION = "2.0.0.rc1"
 end

data/nugrant.gemspec

@@ -28,6 +28,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test/lib)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "insensitive_hash", "~> 0.3"
   gem.add_dependency "multi_json", "~> 1.8"
 end

data/test/lib/nugrant/test_bag.rb

@@ -152,7 +152,7 @@ module Nugrant
 
       bag1.merge!(bag2);
 
-      assert_equal({:first => [1, 2, 2, 3]}, bag1.to_hash())
+      assert_equal({:first => [2, 3, 1, 2]}, bag1.to_hash())
 
       bag1 = create_bag({"first" => [1, 2]}, :array_merge_strategy => :concat)
       bag2 = create_bag({:first => "string"})
@@ -162,6 +162,24 @@ module Nugrant
       assert_equal({:first => "string"}, bag1.to_hash())
     end
 
+    def test_merge_hash_keeps_indifferent_access
+      bag1 = create_bag({"first" => {:second => [1, 2]}})
+      bag1.merge!({:third => "three", "first" => {:second => [3, 4]}})
+
+      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)
+    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)
+    end
+
     def test_nil_key()
       assert_raises(ArgumentError) do
         create_bag({nil => "value"})
@@ -219,9 +237,151 @@ module Nugrant
         "Some value"
       end)
 
-      assert_equal("Some value", bag.invalid_value)
-      assert_equal("Some value", bag["invalid_value"])
-      assert_equal("Some value", bag[:invalid_value])
+      assert_all_access_equal("Some value", bag, :invalid_value)
+    end
+
+    def test_walk_bag
+      bag = create_bag({
+        :first => {
+          :level1 => "value1",
+          :level2 => "value2",
+        },
+        :second => {
+          :level1 => "value3",
+          :level2 => "value4",
+        },
+        :third => "value5"
+      })
+
+      lines = []
+      bag.walk do |path, key, value|
+        lines << "Path (#{path}), Key (#{key}), Value (#{value})"
+      end
+
+      assert_equal([
+        "Path ([:first, :level1]), Key (level1), Value (value1)",
+        "Path ([:first, :level2]), Key (level2), Value (value2)",
+        "Path ([:second, :level1]), Key (level1), Value (value3)",
+        "Path ([:second, :level2]), Key (level2), Value (value4)",
+        "Path ([:third]), Key (third), Value (value5)",
+      ], lines)
+    end
+
+    def test_merge
+      bag1 = create_bag({
+        :first => {
+          :level1 => "value1",
+          :level2 => "value2",
+        },
+        :second => {
+          :level1 => "value3",
+          :level2 => "value4",
+        },
+        :third => "value5"
+      })
+
+      bag2 = create_bag({
+        :first => {
+          :level2 => "overriden2",
+        },
+        :second => {
+          :level1 => "value3",
+          :level2 => "value4",
+        },
+        :third => "overriden5"
+      })
+
+      bag3 = bag1.merge(bag2)
+
+      refute_same(bag1, bag3)
+      refute_same(bag2, bag3)
+
+      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)
+    end
+
+    def test_merge!
+      bag1 = create_bag({
+        :first => {
+          :level1 => "value1",
+          :level2 => "value2",
+        },
+        :second => {
+          :level1 => "value3",
+          :level2 => "value4",
+        },
+        :third => "value5"
+      })
+
+      bag2 = create_bag({
+        :first => {
+          :level2 => "overriden2",
+        },
+        :second => {
+          :level1 => "value3",
+          :level2 => "value4",
+        },
+        :third => "overriden5"
+      })
+
+      bag3 = bag1.merge!(bag2)
+
+      assert_same(bag1, bag3)
+      refute_same(bag2, bag3)
+
+      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)
+    end
+
+    def test_merge_hash()
+      bag1 = create_bag({"first" => {:second => [1, 2]}}, :array_merge_strategy => :extend)
+
+      bag1.merge!({"first" => {:second => [2, 3]}});
+
+      assert_equal({:first => {:second => [1, 2, 3]}}, bag1.to_hash())
+    end
+
+    def test_merge_custom_array_merge_strategy()
+      bag1 = create_bag({"first" => {:second => [1, 2]}}, :array_merge_strategy => :extend)
+
+      bag1.merge!({"first" => {:second => [2, 3]}}, :array_merge_strategy => :replace);
+
+      assert_equal({:first => {:second => [2, 3]}}, bag1.to_hash())
+    end
+
+    def test_merge_custom_invalid_array_merge_strategy()
+      bag1 = create_bag({"first" => {:second => [1, 2]}}, :array_merge_strategy => :extend)
+      bag2 = bag1.merge({"first" => {:second => [2, 3]}}, :array_merge_strategy => nil);
+
+      assert_equal({:first => {:second => [1, 2, 3]}}, bag2.to_hash())
+
+      bag2 = bag1.merge({"first" => {:second => [2, 3]}}, :array_merge_strategy => :invalid);
+
+      assert_equal({:first => {:second => [1, 2, 3]}}, bag2.to_hash())
+    end
+
+    def test_change_config
+      bag1 = create_bag({"first" => [1, 2]}, :array_merge_strategy => :extend)
+      bag2 = create_bag({:first => [2, 3]})
+
+      bag3 = bag1.merge!(bag2);
+      bag3.config = {
+        :array_merge_strategy => :concat
+      }
+
+      bag3.merge!({"first" => [1, 2, 3]})
+
+      assert_equal([1, 2, 3, 1, 2, 3], bag3['first'])
     end
   end
 end

data/test/lib/nugrant/test_config.rb

@@ -119,5 +119,61 @@ module Nugrant
         Nugrant::Config.new({:params_format => :invalid})
       end
     end
+
+    def test_merge
+      config1 = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :current_path => nil,
+      })
+
+      config2 = Nugrant::Config.new({
+        :params_filename => ".overrideparams",
+        :current_path => "something",
+      })
+
+      config3 = config1.merge(config2)
+
+      refute_same(config1, config3)
+      refute_same(config2, config3)
+
+      assert_equal(Nugrant::Config.new({
+        :params_filename => config2[:params_filename],
+        :params_format => config2[:params_format],
+        :current_path => config2[:current_path],
+        :user_path => config2[:user_path],
+        :system_path => config2[:system_path],
+        :array_merge_strategy => config2[:array_merge_strategy],
+        :key_error => config2[:key_error],
+        :parse_error => config2[:parse_error],
+      }), config3)
+    end
+
+    def test_merge!
+      config1 = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :current_path => nil,
+      })
+
+      config2 = Nugrant::Config.new({
+        :params_filename => ".overrideparams",
+        :current_path => "something",
+      })
+
+      config3 = config1.merge!(config2)
+
+      assert_same(config1, config3)
+      refute_same(config2, config3)
+
+      assert_equal(Nugrant::Config.new({
+        :params_filename => config2[:params_filename],
+        :params_format => config2[:params_format],
+        :current_path => config2[:current_path],
+        :user_path => config2[:user_path],
+        :system_path => config2[:system_path],
+        :array_merge_strategy => config2[:array_merge_strategy],
+        :key_error => config2[:key_error],
+        :parse_error => config2[:parse_error],
+      }), config3)
+    end
   end
 end

data/test/lib/nugrant/test_parameters.rb

@@ -10,7 +10,7 @@ module Nugrant
     @@FORMATS = [:json, :yaml]
     @@INVALID_PATH = "impossible_file_path.yamljson.impossible"
 
-    def create_parameters(format, current_filename, user_filename, system_filename)
+    def create_parameters(format, current_filename, user_filename, system_filename, defaults = {}, options = {})
       extension = case
         when format = :json
           "json"
@@ -26,11 +26,12 @@ module Nugrant
       user_path = "#{resource_path}/#{user_filename}.#{extension}" if user_filename
       system_path = "#{resource_path}/#{system_filename}.#{extension}" if system_filename
 
-      return Nugrant::Parameters.new({
+      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
 
@@ -273,15 +274,149 @@ module Nugrant
       end
     end
 
-    def test_hash_method_collect()
+    def test_enumerable_method_insensitive()
       parameters = create_parameters(:json, "params_simple", invalid_path, invalid_path)
-      parameters.defaults = {"test" => "override1", :level => "new1"}
+      parameters.defaults = {"test" => "override1", :level => :new1}
+
+      assert_equal(1, parameters.count([:test, "value"]))
+      assert_equal(1, parameters.count(["test", "value"]))
+      assert_equal(0, parameters.count(["test"]))
+      assert_equal(0, parameters.count([]))
+      assert_equal(0, parameters.count(:a))
+      assert_equal(0, parameters.count(nil))
+
+      assert_equal(0, parameters.find_index([:test, "value"]))
+      assert_equal(0, parameters.find_index(["test", "value"]))
+      assert_equal(nil, parameters.find_index(["test"]))
+      assert_equal(nil, parameters.find_index([]))
+      assert_equal(nil, parameters.find_index(:a))
+      assert_equal(nil, parameters.find_index(nil))
+      assert_equal(0, parameters.find_index() { |key, value| key == :test and value == "value" })
+
+      assert_equal(false, parameters.include?([:test, "value"]))
+      assert_equal(false, parameters.include?(["test", "value"]))
+    end
 
-      pairs = parameters.collect do |key, value|
-        [key, value]
-      end
+    def test_hash_method_insensitive()
+      parameters = create_parameters(:json, "params_simple", invalid_path, invalid_path)
+      parameters.defaults = {"test" => "override1", :level => :new1}
+
+      assert_equal([:test, "value"], parameters.assoc("test"))
+      assert_equal([:test, "value"], parameters.assoc(:test))
+
+      # compare_by_identity ?
+
+      parameters.delete("test")
+      assert_equal(nil, parameters.assoc("test"))
+      assert_equal(nil, parameters.assoc(:test))
+
+      parameters = create_parameters(:json, "params_simple", invalid_path, invalid_path)
+      parameters.defaults = {"test" => "override1", :level => :new1}
+
+      assert_equal([[:test, "value"], [:level,  :new1]], parameters.collect {|key, value| [key, value]})
+
+      assert_equal("value", parameters.fetch("test"))
+      assert_equal("value", parameters.fetch("test", "default"))
+      assert_equal("default", parameters.fetch("unknown", "default"))
+
+      assert_equal(true, parameters.has_key?("test"))
+      assert_equal(true, parameters.has_key?(:test))
+
+      assert_equal(true, parameters.include?("test"))
+      assert_equal(true, parameters.include?(:test))
+
+      assert_equal(true, parameters.member?("test"))
+      assert_equal(true, parameters.member?(:test))
+
+      parameters.store("another", "different")
+      assert_equal(true, parameters.member?("another"))
+      assert_equal(true, parameters.member?(:another))
+    end
+
+    def test_defaults_not_overwritten_on_array_merge_strategy_change
+      parameters = create_parameters(:json, "params_array", invalid_path, invalid_path)
+      parameters.defaults = {"level1" => {"level2" => ["4", "5", "6"]}}
+
+      parameters.array_merge_strategy = :concat
+
+      assert_equal(["4", "5", "6"], parameters.defaults().level1.level2)
+      assert_equal(["1", "2", "3", "4", "5", "6"], parameters.level1.level2)
+    end
+
+    def test_merge()
+      parameters1 = create_parameters(:json, "params_current_1", invalid_path, invalid_path, {
+        "0.1.1" => "default",
+        "0.1.0" => "default",
+        "0.0.1" => "default",
+      })
+
+      parameters2 = create_parameters(:json, "params_current_1", invalid_path, "params_system_1", {
+        "0.1.0" => "default_overriden",
+      })
+
+      parameters3 = parameters1.merge(parameters2)
+
+      refute_same(parameters1, parameters3)
+      refute_same(parameters2, parameters3)
+
+      assert_equal(Nugrant::Parameters, parameters3.class)
+
+      assert_level(parameters3, {
+        :'1.1.1' => "current",
+        :'1.1.0' => "current",
+        :'1.0.1' => "current",
+        :'0.1.1' => "system",
+        :'1.0.0' => "current",
+        :'0.1.0' => "default_overriden",
+        :'0.0.1' => "system",
+      })
+    end
+
+    def test_merge!()
+      parameters1 = create_parameters(:json, "params_current_1", invalid_path, invalid_path, {
+        "0.1.1" => "default",
+        "0.1.0" => "default",
+        "0.0.1" => "default",
+      })
+
+      parameters2 = create_parameters(:json, "params_current_1", invalid_path, "params_system_1", {
+        "0.1.0" => "default_overriden",
+      })
+
+      parameters3 = parameters1.merge!(parameters2)
+
+      assert_same(parameters1, parameters3)
+      refute_same(parameters2, parameters3)
+
+      assert_equal(Nugrant::Parameters, parameters3.class)
+
+      assert_level(parameters3, {
+        :'1.1.1' => "current",
+        :'1.1.0' => "current",
+        :'1.0.1' => "current",
+        :'0.1.1' => "system",
+        :'1.0.0' => "current",
+        :'0.1.0' => "default_overriden",
+        :'0.0.1' => "system",
+      })
+    end
+
+    def test_merge_with_different_array_merge_strategy()
+      parameters1 = create_parameters(:json, "params_array", invalid_path, invalid_path, {
+        "level1" => {
+          "level2" => ["3", "4", "5"]
+        }
+      }, :array_merge_strategy => :replace)
+
+      parameters2 = create_parameters(:json, "params_array", invalid_path, invalid_path, {
+        "level1" => {
+          "level2" => ["3", "6", "7"]
+        }
+      }, :array_merge_strategy => :concat)
+
+      parameters3 = parameters1.merge(parameters2)
 
-      assert_equal([[:test, "value"], [:level, "new1"]], pairs)
+      assert_equal(["1", "2", "3", "3", "6", "7"], parameters3.level1.level2)
     end
 
     def formats()

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: nugrant
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre2
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - Matthieu Vachon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-23 00:00:00.000000000 Z
+date: 2014-06-25 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: insensitive_hash
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -158,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Library to handle user specific parameters from various location.