configurations 2.0.0.pre → 2.0.0

data/lib/configurations/configuration.rb

@@ -1,83 +1,31 @@
-# -*- coding: utf-8 -*-
 module Configurations
-  # Configuration is a blank object in order to allow configuration of various properties including keywords
+  # 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'
-      include ::Kernel
-      undef :nil?, :===, :=~, :!~, :eql?, :hash, :<=>, :class, :singleton_class, :clone, :dup, :initialize_dup,
-            :initialize_clone, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :freeze, :frozen?,
-            :to_s, :inspect, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods,
-            :instance_variables, :instance_variable_get, :instance_variable_set, :instance_variable_defined?,
-            :instance_of?, :kind_of?, :tap, :send, :public_send, :respond_to?, :respond_to_missing?, :extend,
-            :display, :method, :public_method, :define_singleton_method, :to_enum, :enum_for
-    else
-      # @macro [attach] install_kernel_method
-      # @method $1
-      #
-      def self.install_kernel_method(method)
-        kernel_method = ::Kernel.instance_method(method)
-
-        define_method method do |*args, &block|
-          kernel_method.bind(self).call(*args, &block)
-        end
-      end
-
-      # Installs the type asserting is_a? method from Kernel
-      #
-      install_kernel_method(:is_a?)
-
-      # Installs the inspect method from Kernel
-      #
-      install_kernel_method(:inspect)
-
-    end
-
+  class Configuration < BlankObject
     # Initialize a new configuration
     # @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(options={}, &block)
-      @_configurable   = options[:configurable]
-      @_methods        = options[:methods]
-      @_not_configured = options[:not_configured]
+    # @option options [Proc] not_configured a proc to evaluate for
+    #   not_configured properties
 
-      @_writeable    = true
-      @configuration = _configuration_hash
+    def initialize(options = {}, &block)
+      @__methods__ = options.fetch(:methods) { ::Hash.new }
+      @__not_configured__ = options.fetch(:not_configured) { ::Hash.new }
 
-      _evaluate_configurable!
+      @data = __configuration_hash__
 
-      instance_eval(&options[:defaults]) if options[:defaults]
+      __instance_eval__(&options[:defaults]) if options[:defaults]
+      __instance_eval__(&block) if block
 
-      if block
-        instance_eval(&block)
-        self._writeable = false
-      end
+      __install_configuration_methods__
     end
 
-    # Method missing gives access for reading and writing to the underlying configuration hash via dot notation
+    # Method missing gives access to Kernel methods
     #
     def method_missing(method, *args, &block)
-      property = method.to_s[0..-2].to_sym
-      value = args.first
-
-      if _respond_to_writer?(method)
-        _assign!(property, value)
-      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)
+      if __can_delegate_to_kernel?(method)
+        ::Kernel.__send__(method, *args, &block)
       else
         super
       end
@@ -85,27 +33,17 @@ 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_for_write?(method) or _respond_to_property_for_read?(method) or _can_delegate_to_kernel?(method) or !!super
+    def respond_to_missing?(method, include_private = false)
+      __can_delegate_to_kernel?(method) || super
     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 writability for subconfigurations.
-    # @param [Boolean] data true if the configuration should be writeable, false otherwise
-    #
-    def _writeable=(data)
-      @_writeable = data
-      @configuration.each do |k,v|
-        v._writeable = data if v.is_a?(Configuration)
-      end
-    end
-
-    # A convenience accessor to get a hash representation of the current state of the configuration
+    # A convenience accessor to get a hash representation of the
+    # current state of the configuration
     # @return [Hash] the configuration in hash form
     #
     def to_h
-      @configuration.inject({}) do |h, (k,v)|
-        h[k] = v.is_a?(Configuration) ? v.to_h : v
+      @data.reduce({}) do |h, (k, v)|
+        h[k] = v.is_a?(__class__) ? v.to_h : v
 
         h
       end
@@ -114,199 +52,144 @@ 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
-    # @note can only be accessed during writeable state (in configure block). Unassignable values are ignored
     #
     def from_h(h)
-      raise ArgumentError, 'can not dynamically assign values from a hash' unless @_writeable
-
       h.each do |property, value|
-        if value.is_a?(::Hash) && _nested?(property)
-          @configuration[property].from_h(value)
-        elsif _configurable?(property)
-          _assign!(property, value)
+        if value.is_a?(::Hash) && __nested?(property)
+          @data[property].from_h(value)
+        elsif __configurable?(property)
+          __assign!(property, value)
         end
       end
+
+      self
     end
 
     # @param [Symbol] property The property to test for configurability
     # @return [Boolean] whether the given property is configurable
     #
-    def _configurable?(property)
-      _arbitrarily_configurable? or @_configurable.has_key?(property)
+    def __configurable?(_property)
+      fail NotImplementedError, 'must be implemented in subclass'
     end
 
-
-    # @return [Boolean] whether this configuration is arbitrarily configurable
+    # @param [Symbol] property The property to test for
+    # @return [Boolean] whether the given property has been configured
     #
-    def _arbitrarily_configurable?
-      @_configurable.nil? or @_configurable.empty?
+    def __configured?(property)
+      @data.key?(property)
     end
 
-    # @return [Hash] the configurations configurable hash
-    def _configurable
-      @_configurable
+    # @return [Boolean] whether this configuration is empty
+    def __empty?
+      @data.empty?
     end
 
-    private
+    protected
 
-    # @param [Symbol] property The property to test for
-    # @return [Boolean] whether the given property has been configured
+    # Installs the given configuration methods for this configuration
+    # as singleton methods
     #
-    def _configured?(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(configurable: @_configurable, not_configured: @_not_configured) if _configurable?(k)
+    def __install_configuration_methods__
+      @__methods__.each do |meth, block|
+        __define_singleton_method__(meth, &block) if block.is_a?(::Proc)
       end
     end
 
-    # @return [Proc] The not_configured callback
+    # Instantiates an options hash for a nested property
+    # @param [Symbol] property the nested property to instantiate the hash for
+    # @return [Hash] a hash to be used for configuration initialization
     #
-    def _not_configured_callback
-      @_not_configured || ::Proc.new { |key| nil }
-    end
+    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)
 
-    # @return [Boolean] whether the not configured callback has been configured
-    #
-    def _not_configured_callback?
-      !!@_not_configured
+      hash
     end
 
-    # Evaluates configurable properties and passes eventual hashes down to subconfigurations
+    # @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 _evaluate_configurable!
-      return if _arbitrarily_configurable?
+    def __not_configured_callback_for__(property)
+      not_configured = @__not_configured__[property] || ::Proc.new { nil }
 
-      @_configurable.each do |k, assertion|
-        if k.is_a?(::Hash)
-          k.each do |property, nested|
-            @configuration[property] = Configuration.new(configurable: _configurable_hash(property, nested, assertion), not_configured: _not_configured_callback)
-          end
-        end
+      unless not_configured.is_a?(::Proc)
+        blocks = __collect_blocks__(not_configured)
+        not_configured = ->(p) { blocks.each { |b| b.call(p) } }
       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])
+      not_configured
     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
+    # @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 _configurable_hash(property, value, assertion)
-      value = [value] unless value.is_a?(::Array)
-      hash  = ::Hash[value.zip([assertion].flatten*value.size)]
-      hash  = @configuration[property]._configurable.merge(hash) if @configuration.has_key?(property)
+    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
     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)
-      _assert_type!(property, value)
-      v = _evaluate_block!(property, value)
-      value = v unless v.nil?
-      @configuration[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
+    # @return [Hash] A configuration hash instantiating subhashes
+    #   if the key is configurable
     #
-    def _assert_type!(property, value)
-      return unless _evaluable?(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)
+    def __configuration_hash__
+      ::Hash.new do |h, k|
+        h[k] = __class__.new(__options_hash_for__(k)) if __configurable?(k)
+      end
     end
 
-    # Block assertion for configurable properties
+    # Assigns a value after running the assertions
     # @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 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
-    # @return [Boolean] whether this property is nested
-    #
-    def _nested?(property)
-      _arbitrarily_configurable? or @configuration.has_key?(property) and @configuration[property].is_a?(Configuration)
+    def __assign!(property, value)
+      @data[property] = value
     end
 
     # @param [Symbol] method the method to test for
     # @return [Boolean] whether the given method is a writer
     #
-    def _is_writer?(method)
+    def __is_writer?(method)
       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)
+    def __nested?(property)
+      @data[property].is_a?(__class__)
     end
 
     # @param [Symbol] method the method to test for
-    # @return [Boolean] whether the configuration responds to the given method writer
+    # @return [Boolean] whether the configuration can delegate
+    #   the given method to Kernel
     #
-    def _respond_to_writer?(method)
-      _is_writer?(method) and @_writeable and _configurable?(_property_from_writer(method))
-    end
-
-    # @param [Symbol] method the method to test for
-    # @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_for_write?(method)
-      not _is_writer?(method) and @_writeable
-    end
-
-    # @param [Symbol] method the method to test for
-    # @return [Boolean] whether the configuration can delegate the given method to Kernel
-    #
-    def _can_delegate_to_kernel?(method)
+    def __can_delegate_to_kernel?(method)
       ::Kernel.respond_to?(method, true)
     end
 
     # @param [Symbol] method the writer method to turn into a property
     # @return [Symbol] the property derived from the writer method
     #
-    def _property_from_writer(method)
+    def __property_from_writer__(method)
       method.to_s[0..-2].to_sym
     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/strict.rb

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+module Configurations
+  # StrictConfiguration is a blank object with setters and getters defined
+  # according to the configurable settings given
+  #
+  class StrictConfiguration < Configuration
+    # Initialize a new configuration
+    # @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(options = {}, &block)
+      @__configurable__   = options.fetch(:configurable)
+      __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
+        else
+          __install_property__(k)
+        end
+      end
+    end
+
+    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
+
+    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
+    end
+
+    # @param [Symbol] property the property to test for
+    # @return [Boolean] whether this property is pointing to a
+    #   nested configuration
+    #
+    def __nested?(property)
+      respond_to?(property) && __send__(property).is_a?(__class__)
+    end
+
+    # Installs a property setter and getter as singleton methods
+    # @param [Symbol] property the property to install
+    #
+    def __install_property__(property)
+      __install_setter__(property)
+      __install_getter__(property)
+    end
+
+    # Installs a property setter as a singleton method
+    # @param [Symbol] property the property to install the setter for
+    #
+    def __install_setter__(property)
+      __define_singleton_method__ :"#{property}=" do |value|
+        __assign!(property, value)
+      end
+    end
+
+    # Installs a property getter as a singleton method
+    # @param [Symbol] property the property to install the getter for
+    #
+    def __install_getter__(property)
+      __define_singleton_method__ property do
+        @data.fetch(property, &__not_configured_callback_for__(property))
+      end
+    end
+
+    # Installs a property getter for a nested configuration as a
+    # singleton method
+    # @param [Symbol] property the property to install the getter for
+    #
+    def __install_nested_getter__(property)
+      __define_singleton_method__ property do
+        @data[property]
+      end
+    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)
+      __assert_type!(property, value)
+      v = __evaluate_block!(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