configurations 1.4.0 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
----
-SHA1:
-  metadata.gz: 2589e2f8682eac2622c16993dc89aab75f8d0835
-  data.tar.gz: 95c59f8d0f29f2c7cddb2a10dfbfdfa601c11989
-SHA512:
-  metadata.gz: 7d59363609ad7d37bb56a596de502e59eaddbd60dc6e9138bd7f09650e768e6c61f8d22d81191dadf620ac0ce6fe40a2dcaac8ccd6d2971b1f0d6178a7cebc42
-  data.tar.gz: 45603cd9f38b71a9e1086c2b0486f29f089377de972c2b96dbaa7f57d819291f9c677104d8b4b5883b27c5aaff31e2c22031499c54a5b9c05a2ee0647ec1dff3
+--- 
+SHA1: 
+  metadata.gz: e4dac5ba9d58bb68f5ff84dbd03433a9015f976a
+  data.tar.gz: 7ba636f43c643628e1281c2382dc73c4ee4b4a97
+SHA512: 
+  metadata.gz: e2813ce78bbd73297da31cf753832ae05e058bb5d75cdab01a73171302c58c7931979305f4d2dd267e7ab978573134d589ef57a72e6f75887221f791d961dc0f
+  data.tar.gz: 4b102d91d228b20f77097858c6753bd59e880cf060540a4115a5b3452d3bc930ad12804bb77f6fac25c3741cb67ce373c153e29524235709c5229d5b571acd57

data/README.md

@@ -10,7 +10,7 @@ Configurations provides a unified approach to do configurations using the `MyGem
 
 or with Bundler
 
-`gem 'configurations', '~> 1.4.0'`
+`gem 'configurations', '~> 2.0.0.pre'`
 
 Configurations uses [Semver 2.0](http://semver.org/)
 
@@ -55,6 +55,23 @@ MyGem.configuration.class #=> 'oooh wow'
 MyGem.configuration.foo.bar.baz #=> 'fizz'
 ```
 
+Undefined properties on an arbitrary configuration will return `nil`
+
+```
+MyGem.configuration.not_set #=> nil
+```
+
+If you want to define the behaviour for not set properties yourself, use `not_configured`.
+
+```
+module MyGem
+  not_configured do |prop|
+	raise NoMethodError, "#{prop} must be configured"
+  end
+end
+```
+
+
 ### Second way: Restricted Configuration
 
 If you just want some properties to be configurable, consider this option
@@ -87,6 +104,22 @@ MyGem.configuration.foo #=> 'FOO'
 MyGem.configuration.bar.baz #=> 'FIZZ'
 ```
 
+Not configured properties on a restricted configuration will raise `NoMethodError`
+
+```
+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`.
+
+```
+module MyGem
+  not_configured do |prop|
+	warn :not_configured, "Please configure #{prop} or live in danger"
+  end
+end
+```
+
 ### Third way: Type Restricted Configuration
 
 If you want to make sure your configurations only accept one type, consider this option
@@ -121,18 +154,18 @@ module MyGem
   include Configurations
   configurable :foo do |value|
 
-    # The return value is what gets assigned, unless it is nil,
-    # in which case the original value persists
-    #
-    value + ' ooooh my'
+	# The return value is what gets assigned, unless it is nil,
+	# in which case the original value persists
+	#
+	value + ' ooooh my'
   end
   configurable String, bar: :baz do |value|
 
-    # value is guaranteed to be a string at this point
-    #
-    unless %w(bi ba bu).include?(value)
-      raise ArgumentError, 'baz needs to be one of bi, ba, bu'
-    end
+	# value is guaranteed to be a string at this point
+	#
+	unless %w(bi ba bu).include?(value)
+	  raise ArgumentError, 'baz needs to be one of bi, ba, bu'
+	end
   end
 end
 ```
@@ -166,7 +199,7 @@ module MyGem
   include Configurations
   configurable :foo, :bar
   configuration_method :foobar do |arg|
-    foo + bar + arg
+	foo + bar + arg
   end
 end
 ```
@@ -193,7 +226,7 @@ MyGem.configuration.foobar('ARG') #=> 'FOOBARARG'
 module MyGem
   include Configurations
   configuration_defaults do |c|
-    c.foo.bar.baz = 'BAR'
+	c.foo.bar.baz = 'BAR'
   end
 end
 ```

data/lib/configurations.rb

@@ -12,5 +12,5 @@ module Configurations
 
   # Version number of Configurations
   #
-  VERSION = '1.4.0'
+  VERSION = '2.0.0.pre'
 end

data/lib/configurations/configurable.rb

@@ -28,7 +28,13 @@ module Configurations
           #
           def configure(&block)
             raise ArgumentError, 'can not configure without a block' unless block_given?
-            @configuration = #{self}::Configuration.new(@configuration_defaults, @configurable, &block)
+            @configuration = #{base.name}::Configuration.new(
+                                                              defaults: @configuration_defaults,
+                                                              methods: @configuration_methods,
+                                                              configurable: @configurable,
+                                                              not_configured: @not_configured_callback,
+                                                              &block
+                                                            )
           end
         end
       EOF
@@ -85,11 +91,19 @@ module Configurations
       #   end
       #
       def configuration_method(method, &block)
-        raise ArgumentError, "#{method} can not be both a configurable property and a configuration method" if configurable?(method)
+        raise ArgumentError, "can not be both a configurable property and a configuration method" if configurable?(method)
+        @configuration_methods ||= {}
+        @configuration_methods.merge! method => block
+      end
 
-        Configuration.class_eval do
-          define_method method, &block
-        end
+      # not_configured defines the behaviour when a property has not been configured
+      # This can be useful for presence validations of certain properties
+      # or behaviour for undefined properties deviating from the original behaviour
+      # @param [Proc] block the block to evaluate
+      # @yield [Symbol] the property that has not been configured
+      #
+      def not_configured(&block)
+        @not_configured_callback = block
       end
 
       private

data/lib/configurations/configuration.rb

@@ -3,7 +3,6 @@ module Configurations
   # Configuration is a blank object in order to allow configuration of various properties including keywords
   #
   class Configuration < BasicObject
-
     # 1.9 does not allow for method rebinding in another scope
     #
     if ::RUBY_VERSION < '2.0.0'
@@ -33,25 +32,32 @@ module Configurations
       # Installs the inspect method from Kernel
       #
       install_kernel_method(:inspect)
+
     end
 
     # Initialize a new configuration
-    # @param [Proc] configuration_defaults A proc yielding to a default configuration
-    # @param [Hash] configurable a hash of configurable properties and their asserted types if given
+    # @param [Hash] options The options to initialize a configuration with
+    # @option options [Hash] configurable a hash of configurable properties and their asserted types if given
+    # @option options [Hash] methods a hash of method names pointing to procs
+    # @option options [Proc] not_configured a proc to evaluate for not_configured properties
     # @param [Proc] block a block to configure this configuration with
+    # @yield [HostModule::Configuration] a configuration
     # @return [HostModule::Configuration] a configuration
     #
-    def initialize(configuration_defaults, configurable, &block)
-      @_writeable = true
-      @configurable = configurable
+    def initialize(options={}, &block)
+      @_configurable   = options[:configurable]
+      @_methods        = options[:methods]
+      @_not_configured = options[:not_configured]
+
+      @_writeable    = true
       @configuration = _configuration_hash
 
       _evaluate_configurable!
 
-      self.instance_eval(&configuration_defaults) if configuration_defaults
+      instance_eval(&options[:defaults]) if options[:defaults]
 
       if block
-        self.instance_eval(&block)
+        instance_eval(&block)
         self._writeable = false
       end
     end
@@ -64,8 +70,12 @@ module Configurations
 
       if _respond_to_writer?(method)
         _assign!(property, value)
-      elsif _respond_to_property?(method)
+      elsif _respond_to_property_for_write?(method)
         @configuration[method]
+      elsif _respond_to_property_for_read?(method)
+        @configuration.fetch(method, &_not_configured_callback)
+      elsif _has_configuration_method?(method)
+        _exec_configuration_method!(method, *args, &block)
       elsif _can_delegate_to_kernel?(method)
         ::Kernel.send(method, *args, &block)
       else
@@ -76,7 +86,7 @@ module Configurations
     # Respond to missing according to the method_missing implementation
     #
     def respond_to?(method, include_private = false)
-      _respond_to_writer?(method) or _respond_to_property?(method) or _can_delegate_to_kernel?(method) or super
+      _respond_to_writer?(method) or _respond_to_property_for_write?(method) or _respond_to_property_for_read?(method) or _can_delegate_to_kernel?(method) or !!super
     end
 
     # Set the configuration to writeable or read only. Access to writer methods is only allowed within the
@@ -122,19 +132,19 @@ module Configurations
     # @return [Boolean] whether the given property is configurable
     #
     def _configurable?(property)
-      _arbitrarily_configurable? or @configurable.has_key?(property)
+      _arbitrarily_configurable? or @_configurable.has_key?(property)
     end
 
 
     # @return [Boolean] whether this configuration is arbitrarily configurable
     #
     def _arbitrarily_configurable?
-      @configurable.nil? or @configurable.empty?
+      @_configurable.nil? or @_configurable.empty?
     end
 
     # @return [Hash] the configurations configurable hash
     def _configurable
-      @configurable
+      @_configurable
     end
 
     private
@@ -143,31 +153,50 @@ module Configurations
     # @return [Boolean] whether the given property has been configured
     #
     def _configured?(property)
-      @configuration.has_key?(property)
+      @configuration.has_key?(property) or _not_configured_callback? or _arbitrarily_configurable?
     end
 
     # @return [Hash] A configuration hash instantiating subhashes if the key is configurable
     #
     def _configuration_hash
       ::Hash.new do |h, k|
-        h[k] = Configuration.new(nil, @configurable) if _configurable?(k)
+        h[k] = Configuration.new(configurable: @_configurable, not_configured: @_not_configured) if _configurable?(k)
       end
     end
 
+    # @return [Proc] The not_configured callback
+    #
+    def _not_configured_callback
+      @_not_configured || ::Proc.new { |key| nil }
+    end
+
+    # @return [Boolean] whether the not configured callback has been configured
+    #
+    def _not_configured_callback?
+      !!@_not_configured
+    end
+
     # Evaluates configurable properties and passes eventual hashes down to subconfigurations
     #
     def _evaluate_configurable!
       return if _arbitrarily_configurable?
 
-      @configurable.each do |k, assertion|
+      @_configurable.each do |k, assertion|
         if k.is_a?(::Hash)
           k.each do |property, nested|
-            @configuration[property] = Configuration.new(nil, _configurable_hash(property, nested, assertion))
+            @configuration[property] = Configuration.new(configurable: _configurable_hash(property, nested, assertion), not_configured: _not_configured_callback)
           end
         end
       end
     end
 
+    # Executes a configuration method
+    #
+    def _exec_configuration_method!(method, *args, &block)
+      args << block #rbx complains if block is separate in the arguments list
+      instance_exec(*args, &@_methods[method])
+    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
@@ -200,7 +229,7 @@ module Configurations
     def _assert_type!(property, value)
       return unless _evaluable?(property, :type)
 
-      assertion = @configurable[property][:type]
+      assertion = @_configurable[property][:type]
       ::Kernel.raise ConfigurationError, "Expected #{property} to be configured with #{assertion}, but got #{value.class.inspect}", caller unless value.is_a?(assertion)
     end
 
@@ -211,7 +240,7 @@ module Configurations
     def _evaluate_block!(property, value)
       return value unless _evaluable?(property, :block)
 
-      evaluation = @configurable[property][:block]
+      evaluation = @_configurable[property][:block]
       evaluation.call(value)
     end
 
@@ -220,7 +249,7 @@ module Configurations
     # @return [Boolean] whether the given property is assertable
     #
     def _evaluable?(property, evaluation)
-      @configurable and @configurable.has_key?(property) and @configurable[property].is_a?(::Hash) and @configurable[property].has_key?(evaluation)
+      @_configurable and @_configurable.has_key?(property) and @_configurable[property].is_a?(::Hash) and @_configurable[property].has_key?(evaluation)
     end
 
     # @param [Symbol] property The property to test for
@@ -237,6 +266,13 @@ module Configurations
       method.to_s.end_with?('=')
     end
 
+    # @param [Symbol] method the method to test for existence
+    # @return [Boolean] whether the method exists as a configuration method
+    #
+    def _has_configuration_method?(method)
+      @_methods and @_methods.has_key?(method)
+    end
+
     # @param [Symbol] method the method to test for
     # @return [Boolean] whether the configuration responds to the given method writer
     #
@@ -245,10 +281,17 @@ module Configurations
     end
 
     # @param [Symbol] method the method to test for
-    # @return [Boolean] whether the configuration responds to the given property as a method
+    # @return [Boolean] whether the configuration responds to the given property as a method during readable state
+    #
+    def _respond_to_property_for_read?(method)
+      not _is_writer?(method) and _configured?(method)
+    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
     #
-    def _respond_to_property?(method)
-      not _is_writer?(method) and (@_writeable or _configured?(method))
+    def _respond_to_property_for_write?(method)
+      not _is_writer?(method) and @_writeable
     end
 
     # @param [Symbol] method the method to test for

data/test/configurations/test_configurable_with_blocks_configuration.rb

@@ -2,8 +2,8 @@ require 'test_helper'
 
 class TestStricterConfigurationWithBlock < Minitest::Test
 
-  BlocksConfigurationTestModule = testmodule_for(Configurations)
-  BlocksConfigurationTestModule.module_eval do
+  module BlocksConfigurationTestModule
+    include Configurations
     configurable :property1, :property2 do |value|
       value.to_s + 'oooh'
     end

data/test/configurations/test_configuration.rb

@@ -2,11 +2,8 @@ require 'test_helper'
 
 class TestConfiguration < Minitest::Test
 
-  ConfigurationTestModule = testmodule_for(Configurations)
-  ConfigurationDefaultTestModule = testmodule_for(Configurations)
-  ConfigurationNoDefaultTestModule = testmodule_for(Configurations)
-
-  ConfigurationTestModule.module_eval do
+  module ConfigurationTestModule
+    include Configurations
     configuration_defaults do |c|
       c.uh.this.is.neat = 'NEAT'
       c.pah = 'PUH'
@@ -15,16 +12,33 @@ class TestConfiguration < Minitest::Test
     end
   end
 
-  ConfigurationDefaultTestModule.module_eval do
+  module ConfigurationDefaultTestModule
+    include Configurations
     configuration_defaults do |c|
       c.set = 'SET'
     end
   end
 
+  module ConfigurationNoDefaultTestModule
+    include Configurations
+  end
+
+  module ConfigurationNotConfiguredTestModule
+    include Configurations
+    configuration_defaults do |c|
+      c.set.set = 'SET'
+    end
+
+    not_configured do |property|
+      raise ArgumentError, "#{property} must be configured"
+    end
+  end
+
   def setup
     ConfigurationTestModule.configure do |c|
       c.basic = 'BASIC'
       c.class = 'KEY'
+      c.puts = 'OH'
       c.overwriteee = 'YEAH'
       c.overwrite.this = 'OVERWRITE'
       c.github.repo = 'github.com/beatrichartz/configurations'
@@ -33,6 +47,8 @@ class TestConfiguration < Minitest::Test
     end
 
     @configuration = ConfigurationTestModule.configuration
+    @not_configured_configuration = ConfigurationNotConfiguredTestModule.configuration
+    @defaults_configuration = ConfigurationDefaultTestModule.configuration
   end
 
   def test_configuration_is_subclass_of_host_module
@@ -46,6 +62,7 @@ class TestConfiguration < Minitest::Test
                      this: { is: { neat: 'NEAT' } }
                    },
                    pah: 'PUH',
+                   puts: 'OH',
                    overwrite: {
                      this: 'OVERWRITE'
                    },
@@ -76,7 +93,7 @@ class TestConfiguration < Minitest::Test
   end
 
   def test_defaults_without_configure
-    assert_equal 'SET', ConfigurationDefaultTestModule.configuration.set
+    assert_equal 'SET', @defaults_configuration.set
   end
 
   def test_no_defaults_without_configure
@@ -112,18 +129,34 @@ class TestConfiguration < Minitest::Test
     assert_equal 'something', @configuration.something.else.entirely.nested.deep.below
   end
 
-  def test_not_callable_with_undefined_property
-    assert_raises NoMethodError do
-      @configuration.somethings
+  def test_respond_to_with_undefined_property
+    assert_equal true, @configuration.respond_to?(:somethings)
+  end
+
+  def test_nil_with_undefined_property
+    assert_nil @configuration.somethings
+  end
+
+  def test_overwritten_kernel_method
+    assert_equal 'OH', @configuration.puts
+  end
+
+  def test_not_configured_callback
+    assert_raises ArgumentError do
+      @not_configured_configuration.something
     end
   end
 
-  def test_method_missing_on_kernel_method
-    assert_raises StandardError do
-      @configuration.raise StandardError
+  def test_nested_not_configured_callback
+    assert_raises ArgumentError do
+      @not_configured_configuration.set.something
     end
   end
 
+  def test_nested_configured_property_with_not_configured
+    assert_equal 'SET', @not_configured_configuration.set.set
+  end
+
   def test_respond_to_on_writer_while_writeable
     ConfigurationTestModule.configure do |c|
       assert_equal true, c.respond_to?(:pah=)
@@ -135,17 +168,15 @@ class TestConfiguration < Minitest::Test
   end
 
   def test_respond_to_on_kernel_method
-    assert_equal true, @configuration.respond_to?(:puts)
+    assert_equal true, @configuration.respond_to?(:raise)
   end
 
   def test_method_missing_on_non_kernel_method
-    assert_raises NoMethodError do
-      @configuration.blabla
-    end
+    assert_nil @configuration.blabla
   end
 
   def test_respond_to_missing_on_non_kernel_method
-    assert_equal false, @configuration.respond_to?(:bbaaaaa)
+    assert_equal true, @configuration.respond_to?(:bbaaaaa)
   end
 
 end

data/test/configurations/test_configuration_methods.rb

@@ -2,8 +2,9 @@ require 'test_helper'
 
 class TestConfigurationMethods < Minitest::Test
 
-  ConfigurationMethodsClassModule = testmodule_for(Configurations)
-  ConfigurationMethodsClassModule.module_eval do
+  module ConfigurationMethodsClassModule
+    include Configurations
+
     class MyClass
       attr_reader :props
       def initialize(*props)
@@ -27,13 +28,24 @@ class TestConfigurationMethods < Minitest::Test
     end
   end
 
+  module ConfigurationNoMethodsClassModule
+    include Configurations
+
+    configurable :property3
+  end
+
   def setup
     ConfigurationMethodsClassModule.configure do |c|
       c.property1 = :one
       c.property2 = :two
     end
 
+    ConfigurationNoMethodsClassModule.configure do |c|
+      c.property3 = :three
+    end
+
     @configuration = ConfigurationMethodsClassModule.configuration
+    @no_method_configuration = ConfigurationNoMethodsClassModule.configuration
   end
 
   def test_configuration_method
@@ -64,4 +76,10 @@ class TestConfigurationMethods < Minitest::Test
     end
   end
 
+  def test_configuration_methods_unaffected
+    assert_raises NoMethodError do
+      @no_method_configuration.method3('ARG')
+    end
+  end
+
 end

data/test/configurations/test_stricter_configuration.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
 class TestStricterConfiguration < Minitest::Test
+  module StrictConfigurationTestModule
+    include Configurations
 
-  StrictConfigurationTestModule = testmodule_for(Configurations)
-  StrictConfigurationTestModule.module_eval do
     configurable :property1, :property2
     configurable String, :property3
     configurable Symbol, property4: :property5, property6: [:property7, :property8]
@@ -13,6 +13,16 @@ class TestStricterConfiguration < Minitest::Test
     configurable Hash, property9: { property10: { property11: :property13 } }
   end
 
+  module StrictConfigurationTestModuleDefaultsError
+    include Configurations
+
+    configurable :property1, :property2
+
+    not_configured do |prop|
+      raise StandardError, 'Problem here'
+    end
+  end
+
   def setup
     StrictConfigurationTestModule.configure do |c|
       c.property1 = 'BASIC1'
@@ -26,8 +36,12 @@ class TestStricterConfiguration < Minitest::Test
       c.property9.property10.property11.property12 = %w(here I am)
       c.property9.property10.property11.property13 = { hi: :bye }
     end
+    StrictConfigurationTestModuleDefaultsError.configure do |c|
+      c.property1 = 'BASIC3'
+    end
 
     @configuration = StrictConfigurationTestModule.configuration
+    @configuration_defaults_error = StrictConfigurationTestModuleDefaultsError.configuration
   end
 
   def test_configurable_when_set_configurable
@@ -65,17 +79,17 @@ class TestStricterConfiguration < Minitest::Test
                      property7: :anything,
                      property8: :everything,
                      property14: 555
-                   }, 
+                   },
                    property9: {
                      property10: {
                        property11: {
-                         property12: %w(here I am), 
+                         property12: %w(here I am),
                          property13: {
                            hi: :bye
                          }
                        }
                      }
-                   }, 
+                   },
                    property1: 'BASIC1',
                    property2: 'BASIC2',
                    property3: 'STRING'
@@ -124,12 +138,26 @@ class TestStricterConfiguration < Minitest::Test
     end
   end
 
+  def test_respond_to_with_undefined_property
+    assert_equal false, @configuration.respond_to?(:property12)
+  end
+
   def test_not_callable_with_undefined_property
     assert_raises NoMethodError do
       @configuration.property12
     end
   end
 
+  def test_not_configured_callback
+    assert_raises StandardError do
+      @configuration_defaults_error.property2
+    end
+  end
+
+  def test_not_configured_callback_not_triggered_for_configured
+    assert_equal 'BASIC3', @configuration_defaults_error.property1
+  end
+
   def test_not_configurable_with_undefined_nested_property
     assert_raises NoMethodError do
       StrictConfigurationTestModule.configure do |c|
@@ -138,10 +166,8 @@ class TestStricterConfiguration < Minitest::Test
     end
   end
 
-  def test_not_callable_with_undefined_nested_property
-    assert_raises NoMethodError do
-      @configuration.property6.property9
-    end
+  def test_callable_with_undefined_nested_property
+    assert_nil @configuration.property6.property9
   end
 
 end

metadata

@@ -1,67 +1,57 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: configurations
-version: !ruby/object:Gem::Version
-  version: 1.4.0
+version: !ruby/object:Gem::Version 
+  version: 2.0.0.pre
 platform: ruby
-authors:
+authors: 
 - Beat Richartz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-27 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-11-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.4'
-  type: :development
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.4'
-- !ruby/object:Gem::Dependency
-  name: yard
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "5.4"
   type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.8"
   type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10'
-description: Configurations provides a unified approach to do configurations with
-  the flexibility to do everything from arbitrary configurations to type asserted
-  configurations for your gem or any other ruby code.
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "10"
+  type: :development
+  version_requirements: *id003
+description: Configurations provides a unified approach to do configurations with the flexibility to do everything from arbitrary configurations to type asserted configurations for your gem or any other ruby code.
 email: attr_accessor@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
-- ".gitignore"
-- ".travis.yml"
+
+files: 
+- .gitignore
+- .travis.yml
 - Gemfile
 - License.txt
 - README.md
@@ -78,31 +68,33 @@ files:
 - test/support/testmodules.rb
 - test/test_helper.rb
 homepage: http://github.com/beatrichartz/configurations
-licenses:
+licenses: 
 - MIT
 metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
   - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Configurations with a configure block from arbitrary to type-restricted for
-  your gem or other ruby code.
-test_files:
+summary: Configurations with a configure block from arbitrary to type-restricted for your gem or other ruby code.
+test_files: 
 - test/configurations/test_configurable_with_blocks_configuration.rb
 - test/configurations/test_configuration.rb
 - test/configurations/test_configuration_methods.rb