configurations 1.1.0 → 1.3.0

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 doc
 coverage
+*.gem

data/.ruby-version

@@ -1 +1 @@
-2.0.0-p481
+1.9.3-p547

data/README.md

@@ -112,13 +112,81 @@ MyGem.configure do |c|
 end
 ```
 
+### Fourth way: Custom asserted or changed values
+
+If you need further assertions or you need to change a value before it gets stored in the configuration, consider passing a block
+
+```
+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'
+  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
+  end
+end
+```
+
+Gives your users:
+
+```
+MyGem.configure do |c|
+  c.foo = 'FOO'
+  c.bar.baz = %w(bi)
+
+  # This would raise the ArgumentError in the block
+  # c.bar.baz = %w(boooh)
+end
+```
+
 Gives you:
 
 ```
-MyGem.configuration.foo #=> 100% String
-MyGem.configuration.bar.baz #=> 100% Array
+MyGem.configuration.foo #=> 'FOO ooooh my'
+MyGem.configuration.bar.baz #=> one of %w(bi ba bu)
 ```
 
+### Configuration Methods
+
+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:
+
+```
+module MyGem
+  include Configurations
+  configurable :foo, :bar
+  configuration_method :foobar do |arg|
+    foo + bar + arg
+  end
+end
+```
+
+Your users do:
+
+```
+MyGem.configure do |c|
+  c.foo = 'FOO'
+  c.bar = 'BAR'
+end
+```
+
+You get:
+
+```
+MyGem.configuration.foobar('ARG') #=> 'FOOBARARG'
+```
+
+
 ### Defaults:
 
 ```
@@ -134,7 +202,6 @@ end
 
 ```
 MyGem.configuration.to_h #=> a Hash
-
 ```
 
 ### Some caveats

data/lib/configurations.rb

@@ -12,5 +12,5 @@ module Configurations
 
   # Version number of Configurations
   #
-  VERSION = '1.1.0'
+  VERSION = '1.3.0'
 end

data/lib/configurations/configurable.rb

@@ -49,11 +49,31 @@ module Configurations
       # configurable can be used to set the properties which should be configurable, as well as a type which
       # the given property should be asserted to
       # @param [Class, Symbol, Hash] properties a type as a first argument to type assert (if any) or nested properties to allow for setting
+      # @param [Proc] block a block with arity 2 to evaluate when a property is set. It will be given: property name and value
       #
-      def configurable(*properties)
+      def configurable(*properties, &block)
         type = properties.shift if properties.first.is_a?(Class)
         @configurable ||= {}
-        @configurable.merge!(to_configurable_hash(properties, type))
+        @configurable.merge!(to_configurable_hash(properties, type, &block))
+      end
+
+      # returns whether a property is set to be configurable
+      # @param [Symbol] property the property to ask status for
+      #
+      def configurable?(property)
+        @configurable.is_a?(Hash) && @configurable.has_key?(property)
+      end
+
+      # configuration method can be used to retrieve properties from the configuration which use your gem's context
+      # @param [Class, Symbol, Hash] properties properties for retrieval
+      # @param [Proc] block the block to evaluate
+      #
+      def configuration_method(method, &block)
+        raise ArgumentError, "#{method} can not be both a configurable property and a configuration method" if configurable?(method)
+
+        Configuration.class_eval do
+          define_method method, &block
+        end
       end
 
       private
@@ -63,8 +83,13 @@ module Configurations
       # @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)
-        Hash[properties.zip(Array(type) * properties.size)]
+      def to_configurable_hash(properties, type, &block)
+        assertion_hash = {}
+        assertion_hash.merge! block: block if block_given?
+        assertion_hash.merge! type: type if type
+
+        assertions = ([assertion_hash] * properties.size)
+        Hash[properties.zip(assertions)]
       end
     end
   end

data/lib/configurations/configuration.rb

@@ -59,21 +59,21 @@ module Configurations
     #
     def method_missing(method, *args, &block)
       property = method.to_s[0..-2].to_sym
+      value = args.first
 
       if _is_writer?(method) && @_writeable && _configurable?(property)
-        _assert_type!(property, args.first)
-        @configuration[property] = args.first
+        _assign!(property, value)
       elsif !_is_writer?(method) && @_writeable || _configured?(method)
         @configuration[method]
       else
-        super
+        ::Kernel.send(method, *args, &block)
       end
     end
 
     # Respond to missing according to the method_missing implementation
     #
     def respond_to_missing?(method, include_private = false)
-      is_setter?(method) || @_writeable || _configured?(method) || super
+      is_setter?(method) || @_writeable || _configured?(method) || ::Kernel.respond_to_missing?(method, include_private)
     end
 
     # Set the configuration to writeable or read only. Access to writer methods is only allowed within the
@@ -98,8 +98,6 @@ module Configurations
       end
     end
 
-    private
-
     # @param [Symbol] property The property to test for configurability
     # @return [Boolean] whether the given property is configurable
     #
@@ -107,6 +105,15 @@ module Configurations
       _arbitrarily_configurable? or @configurable.has_key?(property)
     end
 
+
+    # @return [Boolean] whether this configuration is arbitrarily configurable
+    #
+    def _arbitrarily_configurable?
+      @configurable.nil? or @configurable.empty?
+    end
+
+    private
+
     # @param [Symbol] property The property to test for
     # @return [Boolean] whether the given property has been configured
     #
@@ -127,10 +134,10 @@ module Configurations
     def _evaluate_configurable!
       return if _arbitrarily_configurable?
 
-      @configurable.each do |k, type|
+      @configurable.each do |k, assertion|
         if k.is_a?(::Hash)
           k.each do |property, nested|
-            @configuration[property] = Configuration.new(nil, _to_configurable_hash(nested, type))
+            @configuration[property] = Configuration.new(nil, _to_configurable_hash(nested, assertion))
           end
         end
       end
@@ -140,9 +147,20 @@ module Configurations
     # @param [Class] type the type to assert, if any
     # @return a hash with configurable values pointing to their types
     #
-    def _to_configurable_hash(value, type)
+    def _to_configurable_hash(value, assertion)
       value = [value] unless value.is_a?(::Array)
-      ::Hash[value.zip([type].flatten*value.size)]
+      ::Hash[value.zip([assertion].flatten*value.size)]
+    end
+
+    # Assigns a value after running the assertions
+    # @param [Symbol] property the property to type test
+    # @param [Any] value the given value
+    #
+    def _assign!(property, value)
+      v = _evaluate_block!(property, value)
+      value = v unless v.nil?
+      _assert_type!(property, value)
+      @configuration[property] = value
     end
 
     # Type assertion for configurable properties
@@ -151,18 +169,29 @@ module Configurations
     # @raise [ConfigurationError] if the given value has the wrong type
     #
     def _assert_type!(property, value)
-      return if _arbitrarily_configurable?
+      return unless _evaluable?(property, :type)
 
-      expected_type = @configurable[property]
-      return if expected_type.nil?
+      assertion = @configurable[property][:type]
+      ::Kernel.raise ConfigurationError, "Expected #{property} to be configured with #{expected_type}, but got #{value.class.inspect}", caller unless value.is_a?(assertion)
+    end
 
-      ::Kernel.raise ConfigurationError, "Expected #{property} to be configured with #{expected_type}, but got #{value.class.inspect}", caller unless value.is_a?(expected_type)
+    # 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
 
-    # @return [Boolean] whether this configuration is arbitrarily configurable
+    # @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 _arbitrarily_configurable?
-      @configurable.nil? or @configurable.empty?
+    def _evaluable?(property, evaluation)
+      @configurable and @configurable.has_key?(property) and @configurable[property].is_a?(::Hash) and @configurable[property].has_key?(evaluation)
     end
 
     # @param [Symbol] method the method to test for

data/test/configurations/test_configurable_with_blocks_configuration.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+
+class TestStricterConfigurationWithBlock < Minitest::Test
+
+  BlocksConfigurationTestModule = testmodule_for(Configurations)
+  BlocksConfigurationTestModule.module_eval do
+    configurable :property1, :property2 do |value|
+      value.to_s + 'oooh'
+    end
+    configurable String, :property3, property4: [:property5, :property6] do |value|
+      raise ArgumentError, 'TEST2' unless %w(hello bye).include?(value)
+      value
+    end
+  end
+
+  def setup
+    BlocksConfigurationTestModule.configure do |c|
+      c.property1 = :one
+      c.property2 = :two
+      c.property3 = 'hello'
+      c.property4.property5 = 'hello'
+      c.property4.property6 = 'bye'
+    end
+
+    @configuration = BlocksConfigurationTestModule.configuration
+  end
+
+  def test_configurable_when_set_configurable_with_block
+    assert_equal 'oneoooh', @configuration.property1
+    assert_equal 'twooooh', @configuration.property2
+  end
+
+  def test_nested_configurable_when_set_configurable_with_block
+    assert_equal 'hello', @configuration.property4.property5
+    assert_equal 'bye', @configuration.property4.property6
+  end
+
+  def test_evaluates_block_for_nested_properties_when_set_configurable_with_block
+    assert_raises ArgumentError, 'TEST2' do
+      BlocksConfigurationTestModule.configure do |c|
+        c.property4.property5 = 'oh'
+      end
+    end
+  end
+
+end

data/test/configurations/test_configuration_methods.rb

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+class TestConfigurationMethods < Minitest::Test
+
+  ConfigurationMethodsClassModule = testmodule_for(Configurations)
+  ConfigurationMethodsClassModule.module_eval do
+    class MyClass
+      attr_reader :props
+      def initialize(*props)
+        @props = props
+      end
+    end
+
+    context = 'CONTEXT'
+    configurable :property1, :property2
+    configuration_method :method1 do
+      MyClass.new(property1, property2)
+    end
+    configuration_method :method2 do
+      context + property1.to_s
+    end
+    configuration_method :method3 do |arg|
+      arg + property1.to_s
+    end
+    configuration_method :kernel_raise do
+      raise StandardError, 'hell'
+    end
+  end
+
+  def setup
+    ConfigurationMethodsClassModule.configure do |c|
+      c.property1 = :one
+      c.property2 = :two
+    end
+
+    @configuration = ConfigurationMethodsClassModule.configuration
+  end
+
+  def test_configuration_method
+    assert_equal [:one, :two], @configuration.method1.props
+  end
+
+  def test_configuration_method_with_context
+    assert_equal 'CONTEXTone', @configuration.method2
+  end
+
+  def test_configuration_method_with_arguments
+    assert_equal 'ARGone', @configuration.method3('ARG')
+  end
+
+  def test_kernel_methods_in_configuration_method
+    assert_raises StandardError, 'hell' do
+      @configuration.kernel_raise
+    end
+  end
+
+  def test_configuration_method_overwrite
+    assert_raises ArgumentError do
+      ConfigurationMethodsClassModule.module_eval do
+        configuration_method :property2 do |c|
+          MyClass.new(c.property2)
+        end
+      end
+    end
+  end
+
+end

metadata

@@ -1,7 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: configurations
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
+  prerelease: 
 platform: ruby
 authors:
 - Beat Richartz
@@ -13,6 +14,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -27,6 +30,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -34,6 +38,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -41,6 +46,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -48,6 +54,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -72,37 +79,42 @@ files:
 - lib/configurations/configurable.rb
 - lib/configurations/configuration.rb
 - lib/configurations/error.rb
+- test/configurations/test_configurable_with_blocks_configuration.rb
 - test/configurations/test_configuration.rb
+- test/configurations/test_configuration_methods.rb
 - test/configurations/test_stricter_configuration.rb
 - test/support/testmodules.rb
 - test/test_helper.rb
 homepage: http://github.com/beatrichartz/configurations
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 1.8.23.2
 signing_key: 
-specification_version: 4
+specification_version: 3
 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
 - test/configurations/test_stricter_configuration.rb
 - test/support/testmodules.rb
 - test/test_helper.rb

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 039597b55adc73ff8cddc05edd7c199f5f2c252f
-  data.tar.gz: 1dec69ab7582283ab60f950dc3caa96e92ff2b95
-SHA512:
-  metadata.gz: e7a927942a4bce9f187a1f491f9469ac898cc62e2687c3b2111163d6b8b665ebaea70767f52fabcdb2e11c1544bc005168610317632ecabe8211373c993897d3
-  data.tar.gz: 97ae55c4e7c2ccae76aab97aa75c912c4b79bbf4a5fc7ebdb752b7150d9b0be821598fc9f060f484e7b456a1a153072a5a5672260c2ca96548d1c2789c6ca89e