configurations 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f9907568167e40b9014fea6fd1999980874e83a8
-  data.tar.gz: 848cd43a6bb4e9c41cf9aa6ff21d1b3966fb7238
+  metadata.gz: a0d503a4163d4238d71c61d2349a78e5f74b59be
+  data.tar.gz: 21343c5d0ff8b12c948caced4f73bb74a04d2083
 SHA512:
-  metadata.gz: a60a00a58aa9af53a443fa2781138c734248ac77b5c2f55724cb330eca8a173636445657e8b7f23a4e907fd319cd9eb651a26ad2216c9d80d9d98501f4e7e646
-  data.tar.gz: 8b0a6f40548e80e3ba7f21eb6674980b2877ff9f270ed02e0c8aadedea532c350270895ccf12108302c74a076967b14f84d5796669e87083e451b1e45ffaa9a8
+  metadata.gz: 71026df8af3278a819d01c1ce0729a27d86ef8a83845596a4301730eee4fb585afeb1ca0f6681c23ac68a1fc74237880fb332bb720d7b6cffb9daecac54f445f
+  data.tar.gz: 354aea5c774097ef557c2ce645f55c124fe2f5f0684fb0c01e205741c8afc8a2134aa00a0994528303c2e9f44d20c4d17387148f1004871ba19d8877d6d2a9be

data/.travis.yml

@@ -6,10 +6,11 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
-  - 2.1.5
-  - 2.2.0
+  - 2.1.6
+  - 2.2.2
   - rbx
   - jruby-19mode
   - jruby-20mode
+  - jruby-head
 
 script: CODECLIMATE_REPO_TOKEN=36cf84c73264d3c361003f66903eec8aa5fb2b3494496f3a9676630518ecc9f9 rake

data/README.md

@@ -6,17 +6,21 @@ Configurations provides a unified approach to do configurations using the `MyGem
 
 ## Install
 
-`gem install configurations`
+```ruby
+gem install configurations
+```
 
 or with Bundler
 
-`gem 'configurations', '~> 2.0.0'`
+```ruby
+gem 'configurations', '~> 2.2.0'
+```
 
 Configurations uses [Semver 2.0](http://semver.org/)
 
 ## Compatibility
 
-Compatible with MRI 1.9.2 - 2.2, Rubinius 2.2, jRuby 1.7 and 9K
+Compatible with MRI 1.9.2 - 2.2, Rubinius 2.x, jRuby 1.7 and 9K
 
 ## Why?
 
@@ -32,7 +36,7 @@ Less time copy pasting configuration code, more time writing exciting code for y
 
 Go boom! with ease. This allows your gem / code users to set any value they like.
 
-```
+```ruby
 module MyGem
   include Configurations
 end
@@ -40,7 +44,7 @@ end
 
 Gives your users:
 
-```
+```ruby
 MyGem.configure do |c|
   c.foo.bar.baz = 'fizz'
   c.hi = 'Hello-o'
@@ -50,20 +54,20 @@ end
 
 Gives you:
 
-```
+```ruby
 MyGem.configuration.class #=> 'oooh wow'
 MyGem.configuration.foo.bar.baz #=> 'fizz'
 ```
 
 Undefined properties on an arbitrary configuration will return `nil`
 
-```
+```ruby
 MyGem.configuration.not_set #=> nil
 ```
 
 If you want to define the behaviour for not set properties yourself, use `not_configured`. You can either define a catch-all `not_configured` which will be executed whenever you call a value that has not been configured and has no default:
 
-```
+```ruby
 module MyGem
   not_configured do |prop|
 	raise NoMethodError, "#{prop} must be configured"
@@ -73,7 +77,7 @@ end
 
 Or you can define finer-grained callbacks:
 
-```
+```ruby
 module MyGem
   not_configured my: { nested: :prop } do |prop|
 	raise NoMethodError, "#{prop} must be configured"
@@ -85,7 +89,7 @@ end
 
 If you just want some properties to be configurable, consider this option
 
-```
+```ruby
 module MyGem
   include Configurations
   configurable :foo, bar: :baz, biz: %i(bi ba bu)
@@ -94,7 +98,7 @@ end
 
 Gives your users:
 
-```
+```ruby
 MyGem.configure do |c|
   c.foo = 'FOO'
   c.bar.baz = 'FIZZ'
@@ -108,23 +112,23 @@ end
 
 Gives you:
 
-```
+```ruby
 MyGem.configuration.foo #=> 'FOO'
 MyGem.configuration.bar.baz #=> 'FIZZ'
 ```
 
 Not configured properties on a restricted configuration will raise `NoMethodError`
 
-```
+```ruby
 MyGem.configuration.not_set #=> <#NoMethodError>
 ```
 
 If you want to define the behaviour for not set properties yourself, use `not_configured`. This will only affect properties set to configurable. All not configurable properties will raise `NoMethodError`.
 
-```
+```ruby
 module MyGem
   not_configured :awesome, :nice do |prop| # omit the arguments to get a catch-all not_configured
-	warn :not_configured, "Please configure #{prop} or live in danger"
+	warn :not_configured, "Please configure #{prop} or live in danger: youtube.com/watch?v=yZ15vCGuvH0"
   end
 end
 ```
@@ -133,7 +137,7 @@ end
 
 If you want to make sure your configurations only accept one type, consider this option
 
-```
+```ruby
 module MyGem
   include Configurations
   configurable String, :foo
@@ -143,7 +147,7 @@ end
 
 Gives your users:
 
-```
+```ruby
 MyGem.configure do |c|
   c.foo = 'FOO'
   c.bar.baz = %w(hello)
@@ -158,7 +162,7 @@ end
 
 If you need further assertions or you need to change a value before it gets stored in the configuration, consider passing a block
 
-```
+```ruby
 module MyGem
   include Configurations
   configurable :foo do |value|
@@ -181,7 +185,7 @@ end
 
 Gives your users:
 
-```
+```ruby
 MyGem.configure do |c|
   c.foo = 'FOO'
   c.bar.baz = %w(bi)
@@ -193,7 +197,7 @@ end
 
 Gives you:
 
-```
+```ruby
 MyGem.configuration.foo #=> 'FOO ooooh my'
 MyGem.configuration.bar.baz #=> one of %w(bi ba bu)
 ```
@@ -203,7 +207,7 @@ MyGem.configuration.bar.baz #=> one of %w(bi ba bu)
 You might want to define methods on your configuration which use configuration values to bring out another value.
 This is what `configuration_method` is here to help you with:
 
-```
+```ruby
 module MyGem
   include Configurations
   configurable :foo, :bar
@@ -215,7 +219,7 @@ end
 
 Your users do:
 
-```
+```ruby
 MyGem.configure do |c|
   c.foo = 'FOO'
   c.bar = 'BAR'
@@ -224,13 +228,13 @@ end
 
 You get:
 
-```
+```ruby
 MyGem.configuration.foobar('ARG') #=> 'FOOBARARG'
 ```
 
 configuration methods can also be installed on nested properties using hashes:
 
-```
+```ruby
 configuration_method foo: :bar do |arg|
   foo + bar + arg
 end
@@ -238,7 +242,7 @@ end
 
 ### Defaults:
 
-```
+```ruby
 module MyGem
   include Configurations
   configuration_defaults do |c|
@@ -249,7 +253,7 @@ end
 
 ### Get a hash if you need it
 
-```
+```ruby
 MyGem.configuration.to_h #=> a Hash
 ```
 
@@ -257,7 +261,7 @@ MyGem.configuration.to_h #=> a Hash
 
 Sometimes your users will have a hash of configuration values which are not handy to press into the block form. In that case, they can use `from_h` inside the `configure` block to either read in the full or a nested configuration. With a everything besides arbitrary configurations, `from_h` can also be used outside the block.
 
-```
+```ruby
 yaml_hash = YAML.load_file('configuration.yml')
 
 MyGem.configure do |c|
@@ -268,8 +272,23 @@ end
 
 ### Some caveats
 
-The `to_h` from above is along with `method_missing`, `object_id` and `initialize` and `singleton_class` the only purposely defined API method which you can not overwrite with a configuration value.
-Apart from these methods, you should be able to set pretty much any property name you like. `Configuration` inherits from `BasicObject`, so even `Kernel` and `Object` method names are available.
+#### Reserved Methods
+These are reserved methods on the configuration instance and should not be defined:
+- `initialize`
+- `inspect`
+- `method_missing`
+- `object_id`
+- `singleton_class`
+- `to_h`
+- `to_s`
+
+`Configuration` inherits from `BasicObject`, so method names defined through `Kernel` and `Object` are available.
+
+## Thread safety
+Configuration is synchronized. Re-configuration via the `configure` block switches out the configuration in place rather than mutating its properties, so don't hold on to configuration objects in another context.
+That said, please bear in mind that keeping mutable state in configurations is as bad an idea as every other kind of global mutable state, if you expect values to change at runtime, configurations are not the right place to keep them:
+
+Encourage your users to configure once when initializing the environment, reconfigure on reload, but never ever at runtime.
 
 ## Contributing
 

data/lib/configurations.rb

@@ -16,5 +16,5 @@ module Configurations
 
   # Version number of Configurations
   #
-  VERSION = '2.0.0'
+  VERSION = '2.2.0'
 end

data/lib/configurations/arbitrary.rb

@@ -3,7 +3,7 @@ module Configurations
   # Configuration is a blank object in order to allow configuration of
   # various properties including keywords
   #
-  class ArbitraryConfiguration < Configuration
+  module Arbitrary
     # Initialize a new configuration
     # @param [Hash] options The options to initialize a configuration with
     # @option options [Hash] methods a hash of method names pointing to procs
@@ -50,7 +50,8 @@ module Configurations
     # @return [Configuration] the configuration with values assigned
     # @note can only be accessed during writeable state (in configure block).
     #   Unassignable values are ignored
-    # @raise [ArgumentError] unless used in writeable state (in configure block)
+    # @raise [ArgumentError] unless used in writeable state
+    #   (in configure block)
     #
     def from_h(h)
       unless @__writeable__
@@ -70,8 +71,8 @@ module Configurations
     # 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.
-    # @param [Boolean] data true if the configuration should be writeable, false
-    #   otherwise
+    # @param [Boolean] data true if the configuration should be writeable,
+    #   false otherwise
     #
     def __writeable__=(data)
       @__writeable__ = data
@@ -99,15 +100,16 @@ module Configurations
     end
 
     # @param [Symbol] method the method to test for
-    # @return [Boolean] whether the configuration responds to the given property
-    #   as a method during writeable state
+    # @return [Boolean] whether the configuration responds to the given
+    #   property as a method during writeable state
     #
     def __respond_to_method_for_write?(method)
       !__is_writer?(method) && @__writeable__ && @data[method].is_a?(__class__)
     end
 
     # @param [Symbol] method the method to test for
-    # @return [Boolean] whether the configuration responds to the given property
+    # @return [Boolean] whether the configuration responds to the
+    #   given property
     #
     def __respond_to_method_for_read?(method, *args, &block)
       !__is_writer?(method) && args.empty? && block.nil?

data/lib/configurations/blank_object.rb

@@ -8,6 +8,7 @@ module Configurations
       :equal?,
       :object_id,
       :__id__,
+      :__instance_variables__,
       :__send__,
       :method_missing
     ].freeze
@@ -26,11 +27,12 @@ module Configurations
       :respond_to?,
       :is_a?,
       :inspect,
+      :to_s,
       :object_id,
       # rbx needs the singleton class to access singleton methods
       :singleton_class,
       *ALIAS_KERNEL_METHODS.keys
-    ].freeze
+    ].compact.freeze
 
     # Undefines every instance method except the kept methods
     #

data/lib/configurations/configurable.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Configurations
   # Module configurable provides the API of configurations
   #
@@ -9,16 +11,32 @@ module Configurations
     #
     def included(base)
       install_configure_in(base)
-      base.class_eval do
+      base.instance_eval do
         extend ClassMethods
+
+        # call configuration_mutex once to initialize the value
+        #
+        initialize_configuration!
       end
     end
 
+    def underscore_camelized(string)
+      string.gsub(/::/, '/')
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('-', '_')
+        .downcase
+    end
+
     # Installs #configure in base, and makes sure that it will instantiate
     # configuration as a subclass of the host module
     #
     def install_configure_in(base)
-      base.class_eval <<-EOF
+      base.instance_eval <<-EOF
+        # Configuration class for host module
+        #
+        #{base.name}::Configuration = Class.new(Configurations::Configuration)
+
         # The central configure method
         # @params [Proc] block the block to configure host module with
         # @raise [ArgumentError] error when not given a block
@@ -28,24 +46,50 @@ module Configurations
         #   end
         #
         def self.configure(&block)
-          fail ArgumentError, "configure needs a block" unless block_given?
-          @configuration = #{base.name}.const_get(configuration_type).new(
-                                                          configuration_options,
-                                                          &block
-                                                        )
+          semaphore.synchronize do
+            fail ArgumentError, "configure needs a block" unless block_given?
+            include_configuration_type!(#{base.name}::Configuration)
+
+            set_configuration!(&block)
+          end
+        end
+
+        # A reader for Configuration
+        #
+        def configuration
+          semaphore.synchronize do
+            return @configuration if @configuration
+
+            if @configuration_defaults
+              include_configuration_type!(#{base.name}::Configuration)
+              set_configuration! { }
+            end
+          end
+        end
+
+
+        private
+
+        # Sets the configuration instance variable
+        #
+        def self.set_configuration!(&block)
+          @configuration = #{base.name}::Configuration.__new__(
+                                                      configuration_options,
+                                                      &block
+                                                    )
         end
+
+        @semaphore = Mutex.new
+        def self.semaphore
+          @semaphore
+        end
+
       EOF
     end
 
     # Class methods that will get installed in the host module
     #
     module ClassMethods
-      # A reader for Configuration
-      #
-      def configuration
-        @configuration ||= @configuration_defaults && configure {}
-      end
-
       # Configuration defaults can be used to set the defaults of
       # any Configuration
       # @param [Proc] block setting the default values of the configuration
@@ -73,7 +117,7 @@ module Configurations
       #   end
       #
       def configurable(*properties, &block)
-        type = properties.shift if properties.first.is_a?(Class)
+        type = properties.shift if properties.first.is_a?(Module)
 
         @configurable ||= {}
         @configurable.merge! to_configurable_hash(properties, type, &block)
@@ -102,7 +146,10 @@ module Configurations
       #   end
       #
       def configuration_method(method, &block)
-        fail ArgumentError, "can't be configuration property and a method" if configurable?(method)
+        fail(
+          ArgumentError,
+          "can't be configuration property and a method"
+        ) if configurable?(method)
 
         @configuration_methods ||= {}
         method_hash = if method.is_a?(Hash)
@@ -143,18 +190,30 @@ module Configurations
         end
       end
 
+      private
+
+      def initialize_configuration!
+        @configuration = nil
+      end
+
+      # Include the configuration type module into the host configuration class
+      #
+      def include_configuration_type!(base)
+        return if base.ancestors.include?(configuration_type)
+
+        base.send :include, configuration_type
+      end
+
       # @return the class name of the configuration class to use
       #
       def configuration_type
         if @configurable.nil? || @configurable.empty?
-          :ArbitraryConfiguration
+          Configurations::Arbitrary
         else
-          :StrictConfiguration
+          Configurations::Strict
         end
       end
 
-      private
-
       # Instantiates a configurable hash from a property and a type
       # @param [Symbol, Hash, Array] properties configurable properties,
       #   either single or nested

data/lib/configurations/configuration.rb

@@ -3,6 +3,27 @@ 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
+      # configurations is not part of the public API.
+      #
+      alias_method :__new__, :new
+      private :new
+    end
+
     # Initialize a new configuration
     # @param [Hash] options The options to initialize a configuration with
     # @option options [Hash] methods a hash of method names pointing to procs
@@ -52,19 +73,38 @@ module Configurations
     # A convenience accessor to instantiate a configuration from a hash
     # @param [Hash] h the hash to read into the configuration
     # @return [Configuration] the configuration with values assigned
+    # @raise [ConfigurationError] if the given hash ambiguous values
+    #     - string and symbol keys with the same string value pointing to
+    #     different values
     #
     def from_h(h)
+      __test_ambiguity!(h)
       h.each do |property, value|
-        if value.is_a?(::Hash) && __nested?(property)
-          @data[property].from_h(value)
-        elsif __configurable?(property)
-          __assign!(property, value)
+        p = property.to_sym
+        if value.is_a?(::Hash) && __nested?(p)
+          @data[p].from_h(value)
+        elsif __configurable?(p)
+          __assign!(p, value)
         end
       end
 
       self
     end
 
+    # Inspect a configuration. Implements inspect without exposing internally
+    # used instance variables.
+    # @param [TrueClass, FalseClass] debug whether to show internals, defaults
+    #     to false
+    # @return [String] The inspect output for this instance
+    #
+    def inspect(debug = false)
+      unless debug
+        '#<%s:0x00%x @data=%s>' % [__class__, object_id << 1, @data.inspect]
+      else
+        super()
+      end
+    end
+
     # @param [Symbol] property The property to test for configurability
     # @return [Boolean] whether the given property is configurable
     #
@@ -91,6 +131,7 @@ module Configurations
     #
     def __install_configuration_methods__
       @__methods__.each do |meth, block|
+        __test_reserved!(meth)
         __define_singleton_method__(meth, &block) if block.is_a?(::Proc)
       end
     end
@@ -101,7 +142,8 @@ module Configurations
     #
     def __options_hash_for__(property)
       hash = {}
-      hash[:not_configured] = __not_configured_hash_for__(property) if @__not_configured__[property]
+      hash[:not_configured] =
+        __not_configured_hash_for__(property) if @__not_configured__[property]
       hash[:methods] = @__methods__[property] if @__methods__.key?(property)
 
       hash
@@ -129,7 +171,9 @@ module Configurations
     #
     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.merge!(
+        @__not_configured__[property]
+      ) if @__not_configured__[property].is_a?(::Hash)
 
       hash
     end
@@ -139,7 +183,7 @@ module Configurations
     #
     def __configuration_hash__
       ::Hash.new do |h, k|
-        h[k] = __class__.new(__options_hash_for__(k)) if __configurable?(k)
+        h[k] = __class__.__new__(__options_hash_for__(k)) if __configurable?(k)
       end
     end
 
@@ -148,6 +192,7 @@ module Configurations
     # @param [Any] value the given value
     #
     def __assign!(property, value)
+      __test_reserved!(property)
       @data[property] = value
     end
 
@@ -177,6 +222,42 @@ 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
     #

data/lib/configurations/error.rb

@@ -2,4 +2,9 @@ module Configurations
   # A configuration Error, raised when configuration gets misconfigured
   #
   ConfigurationError = Class.new(ArgumentError)
+
+  # A reserved method error, raised when configurable is used with
+  # reserved methods
+  #
+  ReservedMethodError = Class.new(NameError)
 end

data/lib/configurations/strict.rb

@@ -3,7 +3,7 @@ module Configurations
   # StrictConfiguration is a blank object with setters and getters defined
   # according to the configurable settings given
   #
-  class StrictConfiguration < Configuration
+  module Strict
     # Initialize a new configuration
     # @param [Hash] options The options to initialize a configuration with
     # @option options [Hash] configurable a hash of configurable properties
@@ -48,6 +48,8 @@ module Configurations
       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!(
@@ -55,6 +57,8 @@ module Configurations
       )
     end
 
+    # Get an options hash for a property
+    #
     def __options_hash_for__(property)
       super(property).merge(configurable: @__nested_configurables__[property])
     end
@@ -85,6 +89,7 @@ module Configurations
     # @param [Symbol] property the property to install
     #
     def __install_property__(property)
+      __test_reserved!(property)
       __install_setter__(property)
       __install_getter__(property)
     end

data/test/configurations/arbitrary/test_reserved_methods.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class TestReservedMethods < ConfigurationsTest
+  def test_raises_when_setup_with_reserved_methods
+    assert_raises Configurations::ReservedMethodError do
+      self.class.setup_with do |c|
+        c.to_s = 'bla'
+      end
+
+      setup
+    end
+  end
+end

data/test/configurations/arbitrary/test_reserved_methods_as_methods.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class TestArbitraryReservedMethodsAsMethods < ConfigurationsTest
+  def test_reserved_methods_not_allowed_as_methods
+    assert_raises Configurations::ReservedMethodError do
+      @module.class_eval do
+        configuration_method :to_h do
+          'h'
+        end
+      end
+
+      setup
+    end
+  end
+end

data/test/configurations/configuration/test_configure_synchronized.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+class TestConfigurationSynchronized < MiniTest::Test
+  module TestModule
+    include Configurations
+
+    configuration_defaults do |c|
+      c.a = 'b'
+    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)
+
+      assert_equal 100, ids.uniq.size
+    end
+  end
+
+  def test_one_instance_mutation
+    there = TestModule.configuration.a
+    t = Thread.new do
+      TestModule.configure do |c|
+        c.a = 'c'
+      end
+
+      there = TestModule.configuration.a
+    end
+
+    t.join
+    here = TestModule.configuration.a
+
+    assert_equal here, there
+  end
+
+  def with_gc_disabled(&_block)
+    GC.disable
+    yield
+    GC.enable
+  end
+end

data/test/configurations/configuration/test_inspect.rb

@@ -0,0 +1,19 @@
+class TestInspect < ConfigurationsTest
+  setup_with {}
+
+  def inspect_output(_configuration)
+    "#<#{self.class.name}::TestModule::Configuration:0x00%x @data={}>" % [@configuration.object_id << 1]
+  end
+
+  def test_non_debug_inspect
+    expected = inspect_output(@configuration)
+
+    assert @configuration.inspect == expected, "Expected inspect to produce output #{expected.inspect}, but got #{@configuration.inspect.inspect}"
+  end
+
+  def test_debug_inspect
+    non_debug = inspect_output(@configuration)
+
+    refute @configuration.inspect(true) == non_debug, "Expected debug inspect to delegate to kernel and produce more output, but got #{@configuration.inspect(true).inspect}"
+  end
+end

data/test/configurations/configuration/test_instantiation_prevention.rb

@@ -0,0 +1,8 @@
+class TestInstantiationPrevention < ConfigurationsTest
+  def test_instantiation_via_new_is_prevented
+    configuration_class = @module.const_get(:Configuration)
+    assert_raises NoMethodError do
+      configuration_class.new({})
+    end
+  end
+end

data/test/configurations/configuration/test_is_a_configuration.rb

@@ -0,0 +1,6 @@
+class TestIsAConfiguration < ConfigurationsTest
+  def test_is_a_configuration
+    configuration_class = @module.const_get(:Configuration)
+    assert @configuration.is_a?(configuration_class), 'Expected configuration to be defined in host module'
+  end
+end

data/test/configurations/shared/hash_methods.rb

@@ -35,6 +35,24 @@ module Tests
         old_to_h = @configuration.to_h.dup
         assert_equal(old_to_h, @module.configure { |c| c.from_h(old_to_h) }.to_h)
       end
+
+      def test_from_h_with_strings
+        old_to_h = @configuration.to_h.dup
+        string_to_h = Hash[old_to_h.map { |k, v| [k.to_s, v] }]
+        assert_equal(old_to_h, @module.configure { |c| c.from_h(string_to_h) }.to_h)
+      end
+
+      def test_from_h_with_ambiguous_strings_and_symbols
+        assert_raises Configurations::ConfigurationError do
+          @module.configure { |c| c.from_h('p1' => 'bla', :p1 => 'blu') }
+        end
+      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
+      end
     end
   end
 end

data/test/configurations/shared/strict_hash_methods.rb

@@ -6,6 +6,15 @@ module Tests
         assert_equal(expected, @module.configure { |c| c.from_h(input) }.to_h)
       end
 
+      def test_from_h_with_strings
+        expected, input = expection_and_input
+        string_input = Hash[input.map { |k, v| [k.to_s, v] }]
+        assert_equal(
+          expected,
+          @module.configure { |c| c.from_h(string_input) }.to_h
+        )
+      end
+
       def test_from_h_outside_block
         expected, input = expection_and_input
         assert_equal(expected, @configuration.from_h(input).to_h)

data/test/configurations/strict/test_reserved_methods.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class TestStrictReservedMethods < ConfigurationsTest
+  def test_reserved_methods_not_configurable
+    assert_raises Configurations::ReservedMethodError do
+      @module.class_eval do
+        configurable :inspect
+      end
+
+      setup
+    end
+  end
+end

data/test/configurations/strict/test_reserved_methods_as_methods.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class TestStrictReservedMethodsAsMethods < ConfigurationsTest
+  def test_reserved_methods_not_allowed_as_methods
+    assert_raises Configurations::ReservedMethodError do
+      @module.class_eval do
+        configuration_method :to_h do
+          'h'
+        end
+      end
+
+      setup
+    end
+  end
+end

data/test/support/setup.rb

@@ -45,7 +45,7 @@ module Test
 
           features.each do |feature|
             method = method(feature)
-            mod.module_eval{ |m| method.call(m) }
+            mod.module_eval { |m| method.call(m) }
           end
 
           @configuration_block = block if block_given?
@@ -117,7 +117,7 @@ module Test
             configurable Hash, p3: { p5: :p7 }
             configurable Symbol, :class
             configurable Proc, :module
-            configurable Class, :puts
+            configurable Module, :puts
           end
         end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: configurations
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Beat Richartz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-07 00:00:00.000000000 Z
+date: 2015-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -80,6 +80,12 @@ files:
 - test/configurations/arbitrary/test_methods.rb
 - test/configurations/arbitrary/test_not_configured.rb
 - test/configurations/arbitrary/test_not_configured_default.rb
+- test/configurations/arbitrary/test_reserved_methods.rb
+- test/configurations/arbitrary/test_reserved_methods_as_methods.rb
+- test/configurations/configuration/test_configure_synchronized.rb
+- test/configurations/configuration/test_inspect.rb
+- test/configurations/configuration/test_instantiation_prevention.rb
+- test/configurations/configuration/test_is_a_configuration.rb
 - test/configurations/shared/defaults.rb
 - test/configurations/shared/hash_methods.rb
 - test/configurations/shared/kernel_methods.rb
@@ -95,6 +101,8 @@ files:
 - test/configurations/strict/test_methods.rb
 - test/configurations/strict/test_not_configured.rb
 - test/configurations/strict/test_not_configured_default.rb
+- test/configurations/strict/test_reserved_methods.rb
+- test/configurations/strict/test_reserved_methods_as_methods.rb
 - test/configurations/strict_types/test.rb
 - test/configurations/strict_types/test_defaults.rb
 - test/configurations/strict_types/test_hash_methods.rb
@@ -148,6 +156,12 @@ test_files:
 - test/configurations/arbitrary/test_methods.rb
 - test/configurations/arbitrary/test_not_configured.rb
 - test/configurations/arbitrary/test_not_configured_default.rb
+- test/configurations/arbitrary/test_reserved_methods.rb
+- test/configurations/arbitrary/test_reserved_methods_as_methods.rb
+- test/configurations/configuration/test_configure_synchronized.rb
+- test/configurations/configuration/test_inspect.rb
+- test/configurations/configuration/test_instantiation_prevention.rb
+- test/configurations/configuration/test_is_a_configuration.rb
 - test/configurations/shared/defaults.rb
 - test/configurations/shared/hash_methods.rb
 - test/configurations/shared/kernel_methods.rb
@@ -163,6 +177,8 @@ test_files:
 - test/configurations/strict/test_methods.rb
 - test/configurations/strict/test_not_configured.rb
 - test/configurations/strict/test_not_configured_default.rb
+- test/configurations/strict/test_reserved_methods.rb
+- test/configurations/strict/test_reserved_methods_as_methods.rb
 - test/configurations/strict_types/test.rb
 - test/configurations/strict_types/test_defaults.rb
 - test/configurations/strict_types/test_hash_methods.rb