configurations 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0d503a4163d4238d71c61d2349a78e5f74b59be
-  data.tar.gz: 21343c5d0ff8b12c948caced4f73bb74a04d2083
+  metadata.gz: 64f706300eff0c3494e39c9e560b63b198513d07
+  data.tar.gz: 82d0bbb8af8484bc6dbcd9c1162f659690d867a3
 SHA512:
-  metadata.gz: 71026df8af3278a819d01c1ce0729a27d86ef8a83845596a4301730eee4fb585afeb1ca0f6681c23ac68a1fc74237880fb332bb720d7b6cffb9daecac54f445f
-  data.tar.gz: 354aea5c774097ef557c2ce645f55c124fe2f5f0684fb0c01e205741c8afc8a2134aa00a0994528303c2e9f44d20c4d17387148f1004871ba19d8877d6d2a9be
+  metadata.gz: 44aa42ce5c00099190352575d9f76fd20ab2fe9135d97a3a6a1df3a24633e512303f55b4eb96d7e263b9b717c33034728d91bc3f699c6ad282db5060da64dfc4
+  data.tar.gz: e42634d42c69e015e6e47b499519c121b0076562983edea0a4f8c40bb0b3cb4e6024bd7f08b489bea51b0b800d1d11315e1df85a705611295ba8ec4a8b745c8a

data/.travis.yml

@@ -3,14 +3,12 @@ branches:
   only:
     - master
 rvm:
-  - 1.9.2
-  - 1.9.3
   - 2.0.0
-  - 2.1.6
-  - 2.2.2
-  - rbx
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - rbx-2
   - jruby-19mode
   - jruby-20mode
-  - jruby-head
 
 script: CODECLIMATE_REPO_TOKEN=36cf84c73264d3c361003f66903eec8aa5fb2b3494496f3a9676630518ecc9f9 rake

data/Rakefile

@@ -5,4 +5,5 @@ task default: :test
 Rake::TestTask.new do |t|
   t.libs << 'test'
   t.pattern = 'test/**/test*.rb'
+  t.warning = true
 end

data/configurations.gemspec

@@ -20,6 +20,8 @@ SUMMARY
   s.test_files        = `git ls-files -- test/*`.split("\n")
 
   s.add_development_dependency 'minitest', '~> 5.4'
+  s.add_development_dependency 'minitest-focus', '~> 1.1'
+  s.add_development_dependency 'test-unit', '~> 3'
   s.add_development_dependency 'yard', '~> 0.8'
   s.add_development_dependency 'rake', '~> 10'
 end

data/lib/configurations.rb

@@ -1,9 +1,13 @@
-require_relative 'configurations/error'
+require_relative 'configurations/arbitrary'
 require_relative 'configurations/blank_object'
+require_relative 'configurations/configurable'
 require_relative 'configurations/configuration'
-require_relative 'configurations/arbitrary'
+require_relative 'configurations/data'
+require_relative 'configurations/error'
+require_relative 'configurations/maps'
+require_relative 'configurations/path'
 require_relative 'configurations/strict'
-require_relative 'configurations/configurable'
+require_relative 'configurations/validators'
 
 # Configurations provides a unified approach to do configurations
 # with the flexibility to do everything from arbitrary configurations
@@ -16,5 +20,5 @@ module Configurations
 
   # Version number of Configurations
   #
-  VERSION = '2.2.0'
+  VERSION = '2.2.1'
 end

data/lib/configurations/arbitrary.rb

@@ -30,7 +30,9 @@ module Configurations
       elsif __respond_to_method_for_write?(method)
         @data[method]
       elsif __respond_to_method_for_read?(method, *args, &block)
-        @data.fetch(method, &__not_configured_callback_for__(method))
+        @data.fetch(method) do
+          @not_configured_blocks.evaluate!(@path.add(method), method)
+        end
       else
         super
       end
@@ -54,20 +56,13 @@ module Configurations
     #   (in configure block)
     #
     def from_h(h)
-      unless @__writeable__
+      unless @writeable
         fail ::ArgumentError, 'can not dynamically assign values from a hash'
       end
 
       super
     end
 
-    # @param [Symbol] property The property to test for configurability
-    # @return [Boolean] whether the given property is configurable
-    #
-    def __configurable?(_property)
-      true
-    end
-
     # Set the configuration to writeable or read only. Access to writer methods
     # is only allowed within the configure block, this method is used to invoke
     # writeability for subconfigurations.
@@ -75,8 +70,8 @@ module Configurations
     #   false otherwise
     #
     def __writeable__=(data)
-      @__writeable__ = data
-      return if @data.nil?
+      @writeable = data
+      return unless defined?(@data) && @data
 
       @data.each do |_k, v|
         v.__writeable__ = data if v.is_a?(__class__)
@@ -104,7 +99,7 @@ module Configurations
     #   property as a method during writeable state
     #
     def __respond_to_method_for_write?(method)
-      !__is_writer?(method) && @__writeable__ && @data[method].is_a?(__class__)
+      !__is_writer?(method) && @writeable && @data[method].is_a?(__class__)
     end
 
     # @param [Symbol] method the method to test for
@@ -120,7 +115,7 @@ module Configurations
     #   state
     #
     def __respond_to_writer?(method)
-      @__writeable__ && __is_writer?(method)
+      @writeable && __is_writer?(method)
     end
   end
 end

data/lib/configurations/blank_object.rb

@@ -31,6 +31,11 @@ module Configurations
       :object_id,
       # rbx needs the singleton class to access singleton methods
       :singleton_class,
+      # rbx needs its private methods
+      :__instance_variable_defined_p__,
+      :__instance_variable_get__,
+      :__instance_variable_set__,
+      :__instance_variable__,
       *ALIAS_KERNEL_METHODS.keys
     ].compact.freeze
 

data/lib/configurations/configurable.rb

@@ -117,10 +117,22 @@ module Configurations
       #   end
       #
       def configurable(*properties, &block)
-        type = properties.shift if properties.first.is_a?(Module)
+        @configurable_properties ||= Maps::Properties.new
+        @configurable_types ||= Maps::Types.new
+        @configurable_blocks ||= Maps::Blocks.new
+
+        type, properties = extract_type(properties)
+        @configurable_properties.add(properties)
+        @configurable_types.add(type, properties)
+        @configurable_blocks.add(block, properties)
+      end
 
-        @configurable ||= {}
-        @configurable.merge! to_configurable_hash(properties, type, &block)
+      def extract_type(properties)
+        if properties.first.is_a?(Module)
+          [properties.first, properties[1...properties.size]]
+        else
+          [nil, properties]
+        end
       end
 
       # returns whether a property is set to be configurable
@@ -128,7 +140,9 @@ module Configurations
       # @return [Boolean] whether the property is configurable
       #
       def configurable?(property)
-        @configurable.is_a?(Hash) && @configurable.key?(property)
+        defined?(@configurable_properties) &&
+          @configurable_properties &&
+          @configurable_properties.configurable?(Path.new([property]))
       end
 
       # configuration method can be used to retrieve properties
@@ -151,14 +165,8 @@ module Configurations
           "can't be configuration property and a method"
         ) if configurable?(method)
 
-        @configuration_methods ||= {}
-        method_hash = if method.is_a?(Hash)
-                        ingest_configuration_block!(method, &block)
-                      else
-                        { method => block }
-                      end
-
-        @configuration_methods.merge! method_hash
+        @configuration_method_blocks ||= Maps::Blocks.new
+        @configuration_method_blocks.add(block, [method])
       end
 
       # not_configured defines the behaviour when a property has not been
@@ -181,12 +189,11 @@ module Configurations
       #   end
       #
       def not_configured(*properties, &block)
-        @not_configured ||= {}
+        @not_configured_blocks ||= Maps::Blocks.new
+        @not_configured_blocks.add(block, properties)
 
         if properties.empty?
-          @not_configured.default_proc = ->(h, k) { h[k] = block }
-        else
-          nested_merge_not_configured_hash(*properties, &block)
+          @not_configured_blocks.add_default(block)
         end
       end
 
@@ -207,41 +214,10 @@ module Configurations
       # @return the class name of the configuration class to use
       #
       def configuration_type
-        if @configurable.nil? || @configurable.empty?
-          Configurations::Arbitrary
-        else
+        if defined?(@configurable_properties) && @configurable_properties && !@configurable_properties.empty?
           Configurations::Strict
-        end
-      end
-
-      # Instantiates a configurable hash from a property and a type
-      # @param [Symbol, Hash, Array] properties configurable properties,
-      #   either single or nested
-      # @param [Class] type the type to assert, if any
-      # @return a hash with configurable values pointing to their types
-      #
-      def to_configurable_hash(properties, type, &block)
-        assertion_hash = {}
-        assertion_hash.merge! block: block if block_given?
-        assertion_hash.merge! type: type if type
-
-        zip_to_hash(assertion_hash, *properties)
-      end
-
-      # Makes all values of hash point to block
-      # @param [Hash] hash the hash to modify
-      # @param [Proc] block the block to point to
-      # @return a hash with all previous values being keys pointing to block
-      #
-      def ingest_configuration_block!(hash, &block)
-        hash.each do |k, v|
-          value = if v.is_a?(Hash)
-                    ingest_configuration_block!(v, &block)
-                  else
-                    zip_to_hash(block, *Array(v))
-                  end
-
-          hash.merge! k => value
+        else
+          Configurations::Arbitrary
         end
       end
 
@@ -249,47 +225,19 @@ module Configurations
       #
       def configuration_options
         {
-          defaults: @configuration_defaults,
-          methods: @configuration_methods,
-          configurable: @configurable,
-          not_configured: @not_configured
-        }.delete_if { |_, value| value.nil? }
-      end
-
-      # merges the properties given into a not_configured hash
-      # @param [Symbol, Hash, Array] properties the properties to merge
-      # @param [Proc] block the block to point the properties to when
-      #  not configured
-      #
-      def nested_merge_not_configured_hash(*properties, &block)
-        nested = properties.last.is_a?(Hash) ? properties.pop : {}
-        nested = ingest_configuration_block!(nested, &block)
-        props = zip_to_hash(block, *properties)
-
-        @not_configured.merge! nested, &method(:configuration_deep_merge)
-        @not_configured.merge! props, &method(:configuration_deep_merge)
-      end
-
-      # Solves merge conflicts when merging
-      # @param [Symbol] key the key that conflicts
-      # @param [Anything] oldval the value of the left side of the merge
-      # @param [Anything] newval the value of the right side of the merge
-      # @return a mergable value with conflicts solved
-      #
-      def configuration_deep_merge(_key, oldval, newval)
-        if oldval.is_a?(Hash) && newval.is_a?(Hash)
-          oldval.merge(newval, &method(:configuration_deep_merge))
-        else
-          Array(oldval) + Array(newval)
-        end
-      end
-
-      # Zip a value with keys to a hash so all keys point to the value
-      # @param [Anything] value the value to point to
-      # @param [Array] keys the keys to install
-      #
-      def zip_to_hash(value, *keys)
-        Hash[keys.zip([value] * keys.size)]
+          defaults:
+            defined?(@configuration_defaults) && @configuration_defaults,
+          properties:
+            defined?(@configurable_properties) && @configurable_properties,
+          types:
+            defined?(@configurable_types) && @configurable_types,
+          blocks:
+            defined?(@configurable_blocks) && @configurable_blocks,
+          method_blocks:
+            defined?(@configuration_method_blocks) && @configuration_method_blocks,
+          not_configured_blocks:
+            defined?(@not_configured_blocks) && @not_configured_blocks,
+        }.keep_if { |_, value| value }
       end
     end
   end

data/lib/configurations/configuration.rb

@@ -3,18 +3,6 @@ module Configurations
   # of various properties including keywords
   #
   class Configuration < BlankObject
-    # Reserved methods are not assignable. They define behaviour needed for
-    # the configuration object to work properly.
-    #
-    RESERVED_METHODS = [
-      :initialize,
-      :inspect,
-      :method_missing,
-      :object_id,
-      :singleton_class, # needed by rbx
-      :to_h,
-      :to_s # needed by rbx / 1.9.3 for inspect
-    ]
 
     class << self
       # Make new a private method, but allow __new__ alias. Instantiating
@@ -31,10 +19,16 @@ module Configurations
     #   not_configured properties
 
     def initialize(options = {}, &block)
-      @__methods__ = options.fetch(:methods) { ::Hash.new }
-      @__not_configured__ = options.fetch(:not_configured) { ::Hash.new }
+      @data = Data.new(__configuration_hash__)
+      @path = options.fetch(:path) { Path.new }
+      @data_map = options.fetch(:data) { Maps::Data.new }
+
+      @methods = options.fetch(:methods) { ::Hash.new }
+      @method_blocks = options.fetch(:method_blocks) { Maps::Blocks.new }
+      @not_configured_blocks = options.fetch(:not_configured_blocks) { Maps::Blocks.new }
 
-      @data = __configuration_hash__
+      @reserved_method_validator = Validators::ReservedMethods.new
+      @key_ambiguity_validator = Validators::Ambiguity.new
 
       __instance_eval__(&options[:defaults]) if options[:defaults]
       __instance_eval__(&block) if block
@@ -78,7 +72,8 @@ module Configurations
     #     different values
     #
     def from_h(h)
-      __test_ambiguity!(h)
+      @key_ambiguity_validator.validate!(h)
+
       h.each do |property, value|
         p = property.to_sym
         if value.is_a?(::Hash) && __nested?(p)
@@ -108,8 +103,12 @@ module Configurations
     # @param [Symbol] property The property to test for configurability
     # @return [Boolean] whether the given property is configurable
     #
-    def __configurable?(_property)
-      fail NotImplementedError, 'must be implemented in subclass'
+    def __configurable?(property)
+      if defined?(@configurable_properties) && @configurable_properties
+        @configurable_properties.configurable?(@path.add(property))
+      else
+        true
+      end
     end
 
     # @param [Symbol] property The property to test for
@@ -130,9 +129,10 @@ module Configurations
     # as singleton methods
     #
     def __install_configuration_methods__
-      @__methods__.each do |meth, block|
-        __test_reserved!(meth)
-        __define_singleton_method__(meth, &block) if block.is_a?(::Proc)
+      entries = @method_blocks.entries_at(@path)
+      entries.each do |meth, entry|
+        @reserved_method_validator.validate!(meth)
+        __define_singleton_method__(meth, &entry.block)
       end
     end
 
@@ -141,39 +141,17 @@ module Configurations
     # @return [Hash] a hash to be used for configuration initialization
     #
     def __options_hash_for__(property)
-      hash = {}
-      hash[:not_configured] =
-        __not_configured_hash_for__(property) if @__not_configured__[property]
-      hash[:methods] = @__methods__[property] if @__methods__.key?(property)
-
-      hash
-    end
-
-    # @param [Symbol] property the property to return the callback for
-    # @return [Proc] a block to use when property is called before
-    #   configuration, defaults to a block yielding nil
-    #
-    def __not_configured_callback_for__(property)
-      not_configured = @__not_configured__[property] || ::Proc.new { nil }
+      nested_path = @path.add(property)
 
-      unless not_configured.is_a?(::Proc)
-        blocks = __collect_blocks__(not_configured)
-        not_configured = ->(p) { blocks.each { |b| b.call(p) } }
-      end
+      hash = {}
+      hash[:path] = nested_path
+      hash[:data] = @data_map
+      hash[:properties] = defined?(@properties) && @properties
 
-      not_configured
-    end
+      hash[:not_configured_blocks] = @not_configured_blocks
 
-    # @param [Symbol] property the property to return the not
-    #   configured hash option for
-    # @return [Hash] a hash which can be used as a not configured
-    #   hash in options
-    #
-    def __not_configured_hash_for__(property)
-      hash = ::Hash.new(&@__not_configured__.default_proc)
-      hash.merge!(
-        @__not_configured__[property]
-      ) if @__not_configured__[property].is_a?(::Hash)
+      hash[:method_blocks] = @method_blocks
+      hash[:methods] = @methods[property] if @methods.key?(property)
 
       hash
     end
@@ -192,7 +170,7 @@ module Configurations
     # @param [Any] value the given value
     #
     def __assign!(property, value)
-      __test_reserved!(property)
+      @data_map.add_entry(@path.add(property), value)
       @data[property] = value
     end
 
@@ -222,55 +200,5 @@ module Configurations
       method.to_s[0..-2].to_sym
     end
 
-    # @param [Symbol] method the method to test for reservedness
-    # @raise [Configurations::ReservedMethodError] raises this error if
-    #    a property is a reserved method.
-    #
-    def __test_reserved!(method)
-      ::Kernel.fail(
-        ::Configurations::ReservedMethodError,
-        "#{method} is a reserved method and can not be assigned"
-      ) if __is_reserved?(method)
-    end
-
-    # @param [Hash] the hash to test for ambiguity
-    # @raise [Configurations::ConfigurationError] raises this error if
-    #    a property is defined ambiguously
-    #
-    def __test_ambiguity!(h)
-      symbols, others = h.keys.partition { |k| k.is_a?(::Symbol) }
-      ambiguous = symbols.map(&:to_s) & others
-
-      unless ambiguous.empty?
-        ::Kernel.fail(
-          ::Configurations::ConfigurationError,
-          "Can not resolve configuration values for #{ambiguous.join(', ')} " \
-          "defined as both Symbol and #{others.first.class.name} keys. " \
-          'Please resolve the ambiguity.'
-        )
-      end
-    end
-
-    # @param [Symbol] method the method to test for
-    # @return [TrueClass, FalseClass] whether the method is reserved
-    #
-    def __is_reserved?(method)
-      RESERVED_METHODS.include?(method)
-    end
-
-    # @param [Hash] a hash to collect blocks from
-    # @return [Proc] a proc to call all the procs
-    #
-    def __collect_blocks__(hash)
-      hash.reduce([]) do |array, (k, v)|
-        array << if v.is_a?(::Hash)
-                   __collect_blocks__(v)
-                 else
-                   v || k
-                 end
-
-        array
-      end.flatten
-    end
   end
 end

data/lib/configurations/data.rb

@@ -0,0 +1,44 @@
+module Configurations
+  # Configuration is a blank object in order to allow configuration
+  # of various properties including keywords
+  #
+  class Data
+    def initialize(
+      data,
+      reserved_method_validator = Validators::ReservedMethods.new
+    )
+      @data = data
+      @reserved_method_validator = reserved_method_validator
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def []=(key, value)
+      @reserved_method_validator.validate!(key)
+
+      @data[key] = value
+    end
+
+    def key?(key)
+      @data.key?(key)
+    end
+
+    def fetch(key, &block)
+      @data.fetch(key, &block)
+    end
+
+    def each(&block)
+      @data.each(&block)
+    end
+
+    def reduce(acc, &block)
+      @data.reduce(acc, &block)
+    end
+
+    def inspect
+      @data.inspect
+    end
+  end
+end

data/lib/configurations/maps.rb

@@ -0,0 +1,6 @@
+require_relative 'maps/blocks'
+require_relative 'maps/data'
+require_relative 'maps/types'
+require_relative 'maps/properties'
+require_relative 'maps/readers'
+require_relative 'maps/writers'

data/lib/configurations/maps/blocks.rb

@@ -0,0 +1,62 @@
+module Configurations
+  module Maps
+    class Blocks
+      class Entry
+        attr_reader :block
+
+        def initialize(block)
+          @block = block
+        end
+
+        def evaluate!(value)
+          return value unless @block
+          block.call(value)
+        end
+      end
+
+      def initialize(reader = Readers::Tolerant.new)
+        @map = {}
+        @reader = reader
+        @default = nil
+      end
+
+      def add_default(block)
+        @default = Entry.new(block)
+      end
+
+      def add(block, properties)
+        properties.each do |property|
+          add_entry(property, block, @map)
+        end
+      end
+
+      def entries_at(path)
+        entries = @reader.read(@map, path) || {}
+        entries.dup.keep_if { |_, v| v.is_a?(Entry) }
+      end
+
+      def evaluate!(path, value)
+        entry = @reader.read(@map, path) || @default
+        return unless entry
+
+        entry.evaluate!(value)
+      end
+
+      def add_entry(property, block, subtree)
+        if property.is_a?(Hash)
+          property.each do |key, val|
+            subtree[key] = add_entry(val, block, subtree.fetch(key, {}))
+          end
+        elsif property.is_a?(Array)
+          property.each do |val|
+            add_entry(val, block, subtree)
+          end
+        else
+          subtree[property] = Entry.new(block)
+        end
+
+        subtree
+      end
+    end
+  end
+end

data/lib/configurations/maps/data.rb

@@ -0,0 +1,30 @@
+module Configurations
+  module Maps
+    class Data
+      class Entry
+        def initialize(value)
+          @value = value
+        end
+      end
+
+      def initialize(
+        reader = Readers::Tolerant.new,
+        writer = Writers::Default.new { |value|
+          Entry.new(value)
+        }
+      )
+        @map = {}
+        @reader = reader
+        @writer = writer
+      end
+
+      def nested?(path)
+        @reader.read(@map, path)
+      end
+
+      def add_entry(path, value)
+        @writer.write(@map, path, value)
+      end
+    end
+  end
+end

data/lib/configurations/maps/properties.rb

@@ -0,0 +1,48 @@
+module Configurations
+  module Maps
+    class Properties
+      attr_reader :map
+      class Entry
+      end
+
+      def initialize(reader = Readers::Tolerant.new)
+        @map = {}
+        @reader = reader
+      end
+
+      def empty?
+        @map.empty?
+      end
+
+      def add(properties)
+        properties.each do |property|
+          add_entry(property, @map)
+        end
+      end
+
+      def entries_at(path)
+        @reader.read(@map, path) || {}
+      end
+
+      def configurable?(path)
+        !!@reader.read(@map, path)
+      end
+
+      def add_entry(property, subtree)
+        if property.is_a?(Hash)
+          property.each do |key, val|
+            subtree[key] = add_entry(val, subtree.fetch(key, {}))
+          end
+        elsif property.is_a?(Array)
+          property.each do |val|
+            add_entry(val, subtree)
+          end
+        else
+          subtree[property] = Entry.new
+        end
+
+        subtree
+      end
+    end
+  end
+end

data/lib/configurations/maps/readers.rb

@@ -0,0 +1 @@
+require_relative 'readers/tolerant'

data/lib/configurations/maps/readers/tolerant.rb

@@ -0,0 +1,13 @@
+module Configurations
+  module Maps
+    module Readers
+      class Tolerant
+        def read(map, path)
+          path.reduce(map) do |map, value|
+            map[value] if map
+          end
+        end
+      end
+    end
+  end
+end

data/lib/configurations/maps/types.rb

@@ -0,0 +1,56 @@
+module Configurations
+  module Maps
+    class Types
+      attr_reader :map
+      class Entry
+        attr_reader :type
+
+        def initialize(type)
+          @type = type
+        end
+
+        def valid?(value)
+          !@type || value.is_a?(@type)
+        end
+      end
+
+      def initialize(reader = Readers::Tolerant.new)
+        @map = {}
+        @reader = reader
+      end
+
+      def add(type, properties)
+        properties.each do |property|
+          add_entry(property, type, @map)
+        end
+      end
+
+      def test!(path, value)
+        entry = @reader.read(@map, path)
+        return unless entry
+
+        fail(
+          ConfigurationError,
+          "#{path.print} must be configured with #{entry.type} (got #{value})",
+          caller
+        ) unless entry.valid?(value)
+      end
+
+      def add_entry(property, type, subtree)
+        if property.is_a?(Hash)
+          property.each do |key, val|
+            subtree[key] = add_entry(val, type, subtree.fetch(key, {}))
+          end
+        elsif property.is_a?(Array)
+          property.each do |val|
+            add_entry(val, type, subtree)
+          end
+        else
+          subtree[property] = Entry.new(type)
+        end
+
+        subtree
+      end
+    end
+  end
+end

data/lib/configurations/maps/writers.rb

@@ -0,0 +1 @@
+require_relative 'writers/default'

data/lib/configurations/maps/writers/default.rb

@@ -0,0 +1,17 @@
+module Configurations
+  module Maps
+    module Writers
+      class Default
+
+        def initialize(&block)
+          @entry_block = block
+        end
+
+        def write(map, path, value)
+          map[path.to_s] = @entry_block.call(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/configurations/path.rb

@@ -0,0 +1,22 @@
+module Configurations
+  class Path
+    def initialize(path = [])
+      @path = path
+    end
+
+    def add(*path)
+      Path.new(@path + path)
+    end
+
+    def reduce(initial, &block)
+      @path.reduce(initial, &block)
+    end
+
+    def to_s
+      @path.join(".")
+    end
+    alias :inspect :to_s
+    alias :print :to_s
+
+  end
+end

data/lib/configurations/strict.rb

@@ -16,65 +16,43 @@ module Configurations
     # @return [HostModule::Configuration] a configuration
     #
     def initialize(options = {}, &block)
-      @__configurable__   = options.fetch(:configurable)
+      @reserved_method_validator = Validators::ReservedMethods.new
+
+      @path       = options.fetch(:path) { Path.new }
+      @properties = options.fetch(:properties) { Maps::Properties.new }
+      @types      = options.fetch(:types)
+      @blocks     = options.fetch(:blocks)
+
       __evaluate_configurable!
 
       super
     end
 
-    # @param [Symbol] property The property to test for configurability
-    # @return [Boolean] whether the given property is configurable
-    #
-    def __configurable?(property)
-      @__configurable__.key?(property) ||
-        @__nested_configurables__.key?(property)
-    end
-
     private
 
     # Evaluates configurable properties and passes eventual hashes
     # down to subconfigurations
     #
     def __evaluate_configurable!
-      @__configurable__.each do |k, assertion|
-        if k.is_a?(::Hash)
-          k.each do |property, nested|
-            __add_to_nested_configurables!(property, nested, assertion)
-            __install_nested_getter__(property)
-          end
+      entries = @properties.entries_at(@path)
+      entries.each do |property, value|
+        if value.is_a?(Maps::Properties::Entry)
+          __install_property__(property)
         else
-          __install_property__(k)
+          __install_nested_getter__(property)
         end
       end
     end
 
-    # Add a property to a nested configurable
-    #
-    def __add_to_nested_configurables!(property, nested, assertion)
-      @__nested_configurables__ ||= ::Hash.new { |h, k| h[k] = {} }
-      @__nested_configurables__[property].merge!(
-        __configurable_hash__(property, nested, assertion)
-      )
-    end
-
     # Get an options hash for a property
     #
     def __options_hash_for__(property)
-      super(property).merge(configurable: @__nested_configurables__[property])
-    end
-
-    # @param [Symbol, Hash, Array] property configurable properties,
-    #   either single or nested
-    # @param [Symbol, Hash, Array] value configurable properties,
-    #   either single or nested
-    # @param [Hash] assertion assertion if any
-    # @return a hash with configurable values pointing to their types
-    #
-    def __configurable_hash__(_property, value, assertion)
-      value = [value] unless value.is_a?(::Array)
-      hash  = ::Hash[value.zip([assertion].flatten * value.size)]
-
-      hash
+      _nested_path = @path.add(property)
+      super(property).merge(
+        properties: @properties,
+        types: @types,
+        blocks: @blocks
+      )
     end
 
     # @param [Symbol] property the property to test for
@@ -89,7 +67,7 @@ module Configurations
     # @param [Symbol] property the property to install
     #
     def __install_property__(property)
-      __test_reserved!(property)
+      @reserved_method_validator.validate!(property)
       __install_setter__(property)
       __install_getter__(property)
     end
@@ -108,7 +86,9 @@ module Configurations
     #
     def __install_getter__(property)
       __define_singleton_method__ property do
-        @data.fetch(property, &__not_configured_callback_for__(property))
+        @data.fetch(property) do
+          @not_configured_blocks.evaluate!(@path.add(property), property)
+        end
       end
     end
 
@@ -127,49 +107,11 @@ module Configurations
     # @param [Any] value the given value
     #
     def __assign!(property, value)
-      __assert_type!(property, value)
-      v = __evaluate_block!(property, value)
+      @types.test!(@path.add(property), value)
+      v = @blocks.evaluate!(@path.add(property), value)
+
       value = v unless v.nil?
       super(property, value)
     end
-
-    # Type assertion for configurable properties
-    # @param [Symbol] property the property to type test
-    # @param [Any] value the given value
-    # @raise [ConfigurationError] if the given value has the wrong type
-    #
-    def __assert_type!(property, value)
-      return unless __evaluable?(property, :type)
-
-      assertion = @__configurable__[property][:type]
-      return if value.is_a?(assertion)
-
-      ::Kernel.fail(
-        ConfigurationError,
-        "#{property} must be configured with #{assertion} (got #{value.class})",
-        caller
-      )
-    end
-
-    # Block assertion for configurable properties
-    # @param [Symbol] property the property to type test
-    # @param [Any] value the given value
-    #
-    def __evaluate_block!(property, value)
-      return value unless __evaluable?(property, :block)
-
-      evaluation = @__configurable__[property][:block]
-      evaluation.call(value)
-    end
-
-    # @param [Symbol] property The property to test for
-    # @param [Symbol] assertion_type The evaluation type type to test for
-    # @return [Boolean] whether the given property is assertable
-    #
-    def __evaluable?(property, evaluation)
-      __configurable?(property) &&
-        @__configurable__[property].is_a?(::Hash) &&
-        @__configurable__[property].key?(evaluation)
-    end
   end
 end

data/lib/configurations/validators.rb

@@ -0,0 +1,2 @@
+require_relative 'validators/ambiguity'
+require_relative 'validators/reserved_methods'

data/lib/configurations/validators/ambiguity.rb

@@ -0,0 +1,26 @@
+module Configurations
+  module Validators
+    class Ambiguity
+      # @param [Hash] the hash to test for ambiguity
+      # @raise [Configurations::ConfigurationError] raises this error if
+      #    a property is defined ambiguously
+      #
+      def validate!(h)
+        symbols, others = h.keys.partition { |k|
+          k.is_a?(::Symbol)
+        }
+
+        ambiguous = symbols.map(&:to_s) & others
+
+        unless ambiguous.empty?
+          ::Kernel.fail(
+            ::Configurations::ConfigurationError,
+            "Can not resolve configuration values for #{ambiguous.join(', ')} " \
+            "defined as both Symbol and #{others.first.class.name} keys. " \
+            'Please resolve the ambiguity.'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/configurations/validators/reserved_methods.rb

@@ -0,0 +1,39 @@
+module Configurations
+  module Validators
+    class ReservedMethods
+      # @param [Symbol] method the method to test for reservedness
+      # @raise [Configurations::ReservedMethodError] raises this error if
+      #    a property is a reserved method.
+      #
+      def validate!(method)
+        ::Kernel.fail(
+          ::Configurations::ReservedMethodError,
+          "#{method} is a reserved method and can not be assigned"
+        ) if reserved?(method)
+      end
+
+      private
+
+      # Reserved methods are not assignable. They define behaviour needed for
+      # the configuration object to work properly.
+      #
+      RESERVED_METHODS = [
+        :initialize,
+        :inspect,
+        :method_missing,
+        :object_id,
+        :singleton_class, # needed by rbx
+        :to_h,
+        :to_s # needed by rbx / 1.9.3 for inspect
+      ]
+
+      # @param [Symbol] method the method to test for
+      # @return [TrueClass, FalseClass] whether the method is reserved
+      #
+      def reserved?(method)
+        RESERVED_METHODS.include?(method)
+      end
+
+    end
+  end
+end

data/test/configurations/configuration/test_configure_synchronized.rb

@@ -1,50 +1,36 @@
 require 'test_helper'
 
 class TestConfigurationSynchronized < MiniTest::Test
-  module TestModule
+  module TestModuleA
     include Configurations
 
     configuration_defaults do |c|
-      c.a = 'b'
+      c.a = -1
     end
   end
 
-  def test_configuration_synchronized
-    with_gc_disabled do
-      ids = []
-      threads = 100.times.map do |i|
-        Thread.new do
-          sleep rand(1000) / 1000.0
-          ids << TestModule.configure do |c|
-            c.a = i
-          end.a
-        end
-      end
-      threads.each(&:join)
+  module TestModuleB
+    include Configurations
 
-      assert_equal 100, ids.uniq.size
+    configuration_defaults do |c|
+      c.a = -1
     end
   end
 
-  def test_one_instance_mutation
-    there = TestModule.configuration.a
-    t = Thread.new do
-      TestModule.configure do |c|
-        c.a = 'c'
+  def test_configuration_synchronized
+    collector = []
+    semaphore = Mutex.new
+    threads = 100.times.map do |i|
+      Thread.new do
+        sleep i%50 / 1000.0
+        collector << TestModuleA.configure do |c|
+          c.a = i
+        end.a
       end
-
-      there = TestModule.configuration.a
     end
+    threads.each(&:join)
 
-    t.join
-    here = TestModule.configuration.a
-
-    assert_equal here, there
+    assert_equal 100, collector.uniq.size
   end
 
-  def with_gc_disabled(&_block)
-    GC.disable
-    yield
-    GC.enable
-  end
 end

data/test/configurations/shared/hash_methods.rb

@@ -49,9 +49,9 @@ module Tests
       end
 
       def test_from_h_with_unambiguous_strings_and_symbols
-        c = @module.configure { |c| c.from_h('p1' => 'bla', :p2 => 2) }
-        assert_equal 2, c.p2
-        assert_equal 'bla', c.p1
+        config = @module.configure { |c| c.from_h('p1' => 'bla', :p2 => 2) }
+        assert_equal 2, config.p2
+        assert_equal 'bla', config.p1
       end
     end
   end

data/test/run

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+
+rake test

data/test/test_helper.rb

@@ -19,4 +19,5 @@ end
 
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'minitest/focus'
 require 'test/unit/assertions'

data/test/watch

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )
+
+while sleep 1; do
+  {
+    find $DIR -name "*.rb";
+    find $DIR/../lib -name "*.rb";
+  } | entr -cdr $DIR/run
+done

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: configurations
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Beat Richartz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-11 00:00:00.000000000 Z
+date: 2016-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -17,13 +17,41 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.4'
-  type: :development
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -31,8 +59,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
-  type: :development
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -45,8 +73,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
-  type: :development
   prerelease: false
+  type: :development
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -72,8 +100,22 @@ files:
 - lib/configurations/blank_object.rb
 - lib/configurations/configurable.rb
 - lib/configurations/configuration.rb
+- lib/configurations/data.rb
 - lib/configurations/error.rb
+- lib/configurations/maps.rb
+- lib/configurations/maps/blocks.rb
+- lib/configurations/maps/data.rb
+- lib/configurations/maps/properties.rb
+- lib/configurations/maps/readers.rb
+- lib/configurations/maps/readers/tolerant.rb
+- lib/configurations/maps/types.rb
+- lib/configurations/maps/writers.rb
+- lib/configurations/maps/writers/default.rb
+- lib/configurations/path.rb
 - lib/configurations/strict.rb
+- lib/configurations/validators.rb
+- lib/configurations/validators/ambiguity.rb
+- lib/configurations/validators/reserved_methods.rb
 - test/configurations/arbitrary/test.rb
 - test/configurations/arbitrary/test_defaults.rb
 - test/configurations/arbitrary/test_hash_methods.rb
@@ -121,9 +163,11 @@ files:
 - test/configurations/strict_with_blocks/test_methods.rb
 - test/configurations/strict_with_blocks/test_not_configured.rb
 - test/configurations/strict_with_blocks/test_not_configured_default.rb
+- test/run
 - test/support/setup.rb
 - test/support/shared.rb
 - test/test_helper.rb
+- test/watch
 homepage: http://github.com/beatrichartz/configurations
 licenses:
 - MIT
@@ -144,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Configurations with a configure block from arbitrary to type-restricted for
@@ -197,7 +241,9 @@ test_files:
 - test/configurations/strict_with_blocks/test_methods.rb
 - test/configurations/strict_with_blocks/test_not_configured.rb
 - test/configurations/strict_with_blocks/test_not_configured_default.rb
+- test/run
 - test/support/setup.rb
 - test/support/shared.rb
 - test/test_helper.rb
+- test/watch
 has_rdoc: