dry-configurable 0.11.6 → 1.0.1

data/lib/dry/configurable/config.rb

@@ -1,11 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
-
-require 'dry/equalizer'
-
-require 'dry/configurable/constants'
-require 'dry/configurable/errors'
+require "set"
 
 module Dry
   module Configurable
@@ -19,12 +14,29 @@ module Dry
       attr_reader :_settings
 
       # @api private
-      attr_reader :_resolved
+      attr_reader :_values
+
+      # @api private
+      attr_reader :_configured
+      protected :_configured
 
       # @api private
-      def initialize(settings)
-        @_settings = settings.dup
-        @_resolved = Concurrent::Map.new
+      def initialize(settings, values: {})
+        @_settings = settings
+        @_values = values
+        @_configured = Set.new
+      end
+
+      # @api private
+      private def initialize_copy(source)
+        super
+        @_values = source.__send__(:dup_values)
+        @_configured = source._configured.dup
+      end
+
+      # @api private
+      def dup_for_settings(settings)
+        dup.tap { |config| config.instance_variable_set(:@_settings, settings) }
       end
 
       # Get config value by a key
@@ -34,9 +46,19 @@ module Dry
       # @return Config value
       def [](name)
         name = name.to_sym
-        raise ArgumentError, "+#{name}+ is not a setting name" unless _settings.key?(name)
 
-        _settings[name].value
+        unless (setting = _settings[name])
+          raise ArgumentError, "+#{name}+ is not a setting name"
+        end
+
+        _values.fetch(name) {
+          # Mutable settings may be configured after read
+          _configured.add(name) if setting.cloneable?
+
+          setting.to_value.tap { |value|
+            _values[name] = value
+          }
+        }
       end
 
       # Set config value.
@@ -45,21 +67,34 @@ module Dry
       # @param [String,Symbol] name
       # @param [Object] value
       def []=(name, value)
-        public_send(:"#{name}=", value)
+        raise FrozenConfigError, "Cannot modify frozen config" if frozen?
+
+        name = name.to_sym
+
+        unless (setting = _settings[name])
+          raise ArgumentError, "+#{name}+ is not a setting name"
+        end
+
+        _configured.add(name)
+
+        _values[name] = setting.constructor.(value)
       end
 
       # Update config with new values
       #
-      # @param values [Hash] A hash with new values
+      # @param values [Hash, #to_hash] A hash with new values
       #
       # @return [Config]
       #
       # @api public
       def update(values)
         values.each do |key, value|
-          case value
-          when Hash
-            self[key].update(value)
+          if self[key].is_a?(self.class)
+            unless value.respond_to?(:to_hash)
+              raise ArgumentError, "#{value.inspect} is not a valid setting value"
+            end
+
+            self[key].update(value.to_hash)
           else
             self[key] = value
           end
@@ -67,62 +102,113 @@ module Dry
         self
       end
 
-      # Dump config into a hash
+      # Returns true if the value for the given key has been set on this config.
+      #
+      # For simple values, this returns true if the value has been explicitly assigned.
+      #
+      # For cloneable (mutable) values, since these are captured on read, returns true if the value
+      # does not compare equally to its corresdponing default value. This relies on these objects
+      # having functioning `#==` checks.
+      #
+      # @return [Bool]
+      #
+      # @api public
+      def configured?(key)
+        if _configured.include?(key) && _settings[key].cloneable?
+          return _values[key] != _settings[key].to_value
+        end
+
+        _configured.include?(key)
+      end
+
+      # Returns the current config values.
+      #
+      # Nested configs remain in their {Config} instances.
       #
       # @return [Hash]
       #
       # @api public
       def values
-        _settings
-          .map { |setting| [setting.name, setting.value] }
-          .map { |key, value| [key, value.is_a?(self.class) ? value.to_h : value] }
-          .to_h
+        # Ensure all settings are represented in values
+        _settings.each { |setting| self[setting.name] unless _values.key?(setting.name) }
+
+        _values
       end
-      alias_method :to_h, :values
-      alias_method :to_hash, :values
 
-      # @api private
-      def finalize!
-        _settings.freeze
-        freeze
+      # Returns config values as a hash, with nested values also converted from {Config} instances
+      # into hashes.
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        values.to_h { |key, value| [key, value.is_a?(self.class) ? value.to_h : value] }
       end
 
       # @api private
-      def pristine
-        self.class.new(_settings.pristine)
+      alias_method :_dry_equalizer_hash, :hash
+
+      # @api public
+      def hash
+        return @__hash__ if instance_variable_defined?(:@__hash__)
+
+        _dry_equalizer_hash
+      end
+
+      # @api public
+      def finalize!(freeze_values: false)
+        return self if frozen?
+
+        values.each_value do |value|
+          if value.is_a?(self.class)
+            value.finalize!(freeze_values: freeze_values)
+          elsif freeze_values
+            value.freeze
+          end
+        end
+
+        # Memoize the hash for the object when finalizing (regardless of whether values themselves
+        # are to be frozen; the intention of finalization is that no further changes should be
+        # made). The benefit of freezing the hash at this point is that it saves repeated expensive
+        # computation (through Dry::Equalizer's hash implementation) if that hash is to be used
+        # later in performance-sensitive situations, such as when serving as a cache key or similar.
+        @__hash__ = _dry_equalizer_hash
+
+        freeze
       end
 
       # @api private
-      def respond_to_missing?(meth, include_private = false)
-        super || _settings.key?(resolve(meth))
+      def pristine
+        self.class.new(_settings)
       end
 
       private
 
-      # @api private
-      def method_missing(meth, *args)
-        setting = _settings[resolve(meth)]
+      def method_missing(name, *args)
+        setting_name = setting_name_from_method(name)
+        setting = _settings[setting_name]
 
         super unless setting
 
-        if setting.writer?(meth)
-          raise FrozenConfig, 'Cannot modify frozen config' if frozen?
-
-          _settings << setting.with(input: args[0])
+        if name.end_with?("=")
+          self[setting_name] = args[0]
         else
-          setting.value
+          self[setting_name]
         end
       end
 
-      # @api private
-      def resolve(meth)
-        _resolved.fetch(meth) { _resolved[meth] = meth.to_s.tr('=', '').to_sym }
+      def respond_to_missing?(meth, include_private = false)
+        _settings.key?(setting_name_from_method(meth)) || super
       end
 
-      # @api private
-      def initialize_copy(source)
-        super
-        @_settings = source._settings.dup
+      def setting_name_from_method(method_name)
+        method_name.to_s.tr("=", "").to_sym
+      end
+
+      def dup_values
+        _values.each_with_object({}) { |(key, val), dup_hsh|
+          dup_hsh[key] = _settings[key].cloneable? ? val.dup : val
+        }
       end
     end
   end

data/lib/dry/configurable/constants.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/core/constants'
-
 module Dry
   # Shared constants
   #

data/lib/dry/configurable/dsl.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/configurable/constants'
-require 'dry/configurable/setting'
-require 'dry/configurable/settings'
-require 'dry/configurable/compiler'
-require 'dry/configurable/dsl/args'
-
 module Dry
   module Configurable
     # Setting DSL used by the class API
@@ -14,49 +8,67 @@ module Dry
     class DSL
       VALID_NAME = /\A[a-z_]\w*\z/i.freeze
 
-      # @api private
       attr_reader :compiler
 
-      # @api private
       attr_reader :ast
 
-      # @api private
-      def initialize(&block)
+      attr_reader :options
+
+      def initialize(**options, &block)
         @compiler = Compiler.new
         @ast = []
+        @options = options
         instance_exec(&block) if block
       end
 
-      # Register a new setting node and compile it into a setting object
+      # Registers a new setting node and compile it into a setting object
       #
       # @see ClassMethods.setting
-      # @api public
+      # @api private
       # @return Setting
-      def setting(name, *args, &block)
+      def setting(name, **options, &block) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
         unless VALID_NAME.match?(name.to_s)
           raise ArgumentError, "#{name} is not a valid setting name"
         end
 
-        args = Args.new(args)
-
-        args.ensure_valid_options
+        ensure_valid_options(options)
 
-        default, opts = args
+        options = {default: default, config_class: config_class, **options}
 
-        node = [:setting, [name.to_sym, default, opts == default ? EMPTY_HASH : opts]]
+        node = [:setting, [name.to_sym, options]]
 
         if block
-          if block.arity.zero?
-            ast << [:nested, [node, DSL.new(&block).ast]]
-          else
-            ast << [:constructor, [node, block]]
-          end
+          ast << [:nested, [node, DSL.new(&block).ast]]
         else
           ast << node
         end
 
         compiler.visit(ast.last)
       end
+
+      def config_class
+        options[:config_class]
+      end
+
+      def default
+        options[:default_undefined] ? Undefined : nil
+      end
+
+      private
+
+      def ensure_valid_options(options)
+        return if options.none?
+
+        invalid_keys = options.keys - Setting::OPTIONS
+
+        raise ArgumentError, "Invalid options: #{invalid_keys.inspect}" unless invalid_keys.empty?
+      end
+
+      # Returns a tuple of valid and invalid options hashes derived from the options hash
+      # given to the setting
+      def valid_and_invalid_options(options)
+        options.partition { |k, _| Setting::OPTIONS.include?(k) }.map(&:to_h)
+      end
     end
   end
 end

data/lib/dry/configurable/errors.rb

@@ -6,7 +6,8 @@ module Dry
   # @api public
   module Configurable
     Error = Class.new(::StandardError)
-    AlreadyIncluded = ::Class.new(Error)
-    FrozenConfig = ::Class.new(Error)
+
+    AlreadyIncludedError = Class.new(Error)
+    FrozenConfigError = Class.new(Error)
   end
 end

data/lib/dry/configurable/extension.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Dry
+  module Configurable
+    class Extension < Module
+      # @api private
+      attr_reader :config_class
+
+      # @api private
+      attr_reader :default_undefined
+
+      # @api private
+      def initialize(config_class: Configurable::Config, default_undefined: false)
+        super()
+        @config_class = config_class
+        @default_undefined = default_undefined
+        freeze
+      end
+
+      # @api private
+      def extended(klass)
+        super
+        klass.extend(ClassMethods)
+        klass.instance_variable_set(:@__config_extension__, self)
+      end
+
+      # @api private
+      def included(klass)
+        raise AlreadyIncludedError if klass.include?(InstanceMethods)
+
+        super
+
+        klass.class_eval do
+          extend(ClassMethods)
+          include(InstanceMethods)
+          prepend(Initializer)
+
+          class << self
+            undef :config
+            undef :configure
+          end
+        end
+
+        klass.instance_variable_set(:@__config_extension__, self)
+      end
+    end
+  end
+end

data/lib/dry/configurable/instance_methods.rb

@@ -1,10 +1,24 @@
 # frozen_string_literal: true
 
-require 'dry/configurable/config'
-require 'dry/configurable/methods'
+require "dry/configurable/config"
+require "dry/configurable/methods"
 
 module Dry
   module Configurable
+    # Initializer method which is prepended when `Dry::Configurable`
+    # is included in a class
+    #
+    # @api private
+    module Initializer
+      # @api private
+      def initialize(*)
+        @__config__ = self.class.__config_build__(self.class.settings)
+
+        super
+      end
+      ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+    end
+
     # Instance-level API when `Dry::Configurable` is included in a class
     #
     # @api public
@@ -16,20 +30,14 @@ module Dry
       # @return [Config]
       #
       # @api public
-      attr_reader :config
-
-      # @api private
-      def initialize(*)
-        @config = Config.new(self.class._settings.dup)
-        super
+      def config
+        @__config__
       end
 
       # Finalize the config and freeze the object
       #
       # @api public
-      def finalize!
-        return self if frozen?
-
+      def finalize!(freeze_values: false)
         super
         freeze
       end
@@ -39,7 +47,7 @@ module Dry
       # @api public
       def initialize_copy(source)
         super
-        @config = source.config.dup
+        @__config__ = source.config.dup
       end
     end
   end

data/lib/dry/configurable/methods.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry/configurable/errors'
-
 module Dry
   module Configurable
     # Common API for both classes and instances
@@ -10,7 +8,7 @@ module Dry
     module Methods
       # @api public
       def configure(&block)
-        raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+        raise FrozenConfigError, "Cannot modify frozen config" if config.frozen?
 
         yield(config) if block
         self
@@ -21,10 +19,8 @@ module Dry
       # @return [Dry::Configurable::Config]
       #
       # @api public
-      def finalize!
-        return self if config.frozen?
-
-        config.finalize!
+      def finalize!(freeze_values: false)
+        config.finalize!(freeze_values: freeze_values)
         self
       end
     end

data/lib/dry/configurable/setting.rb

@@ -1,102 +1,61 @@
 # frozen_string_literal: true
 
-require 'set'
-
-require 'dry/equalizer'
-
-require 'dry/configurable/constants'
-require 'dry/configurable/config'
+require "set"
 
 module Dry
   module Configurable
-    # This class represents a setting and is used internally.
+    # A defined setting.
     #
-    # @api private
+    # @api public
     class Setting
-      include Dry::Equalizer(:name, :value, :options, inspect: false)
+      include Dry::Equalizer(:name, :default, :constructor, :children, :options, inspect: false)
 
-      OPTIONS = %i[input default reader constructor settings].freeze
+      OPTIONS = %i[default reader constructor mutable cloneable settings config_class].freeze
 
       DEFAULT_CONSTRUCTOR = -> v { v }.freeze
 
-      CLONABLE_VALUE_TYPES = [Array, Hash, Set, Config].freeze
+      MUTABLE_VALUE_TYPES = [Array, Hash, Set, Config].freeze
 
-      # @api private
+      # @api public
       attr_reader :name
 
-      # @api private
-      attr_reader :writer_name
+      # @api public
+      attr_reader :default
 
-      # @api private
-      attr_reader :input
+      # @api public
+      attr_reader :mutable
 
-      # @api private
-      attr_reader :default
+      # @api public
+      attr_reader :constructor
 
-      # @api private
+      # @api public
+      attr_reader :children
+
+      # @api public
       attr_reader :options
 
-      # Specialized Setting which includes nested settings
-      #
       # @api private
-      class Nested < Setting
-        CONSTRUCTOR = Config.method(:new)
-
-        # @api private
-        def pristine
-          with(input: input.pristine)
-        end
-
-        # @api private
-        def constructor
-          CONSTRUCTOR
-        end
+      def self.mutable_value?(value)
+        MUTABLE_VALUE_TYPES.any? { |type| value.is_a?(type) }
       end
 
       # @api private
-      def initialize(name, input: Undefined, default: Undefined, **options)
+      def initialize(
+        name,
+        default:,
+        constructor: DEFAULT_CONSTRUCTOR,
+        children: EMPTY_ARRAY,
+        **options
+      )
         @name = name
-        @writer_name = :"#{name}="
-        @input = input.equal?(Undefined) ? default : input
         @default = default
+        @mutable = children.any? || options.fetch(:mutable) {
+          # Allow `cloneable` as an option alias for `mutable`
+          options.fetch(:cloneable) { Setting.mutable_value?(default) }
+        }
+        @constructor = constructor
+        @children = children
         @options = options
-
-        evaluate if input_defined?
-      end
-
-      # @api private
-      def input_defined?
-        !input.equal?(Undefined)
-      end
-
-      # @api private
-      def value
-        @value ||= evaluate
-      end
-
-      # @api private
-      def evaluated?
-        instance_variable_defined?(:@value)
-      end
-
-      # @api private
-      def nested(settings)
-        Nested.new(name, input: settings, **options)
-      end
-
-      # @api private
-      def pristine
-        with(input: Undefined)
-      end
-
-      # @api private
-      def with(new_opts)
-        self.class.new(name, input: input, default: default, **options, **new_opts)
-      end
-
-      # @api private
-      def constructor
-        options[:constructor] || DEFAULT_CONSTRUCTOR
       end
 
       # @api private
@@ -104,28 +63,22 @@ module Dry
         options[:reader].equal?(true)
       end
 
-      # @api private
-      def writer?(meth)
-        writer_name.equal?(meth)
+      # @api public
+      def mutable?
+        mutable
       end
+      alias_method :cloneable?, :mutable?
 
       # @api private
-      def clonable_value?
-        CLONABLE_VALUE_TYPES.any? { |type| value.is_a?(type) }
-      end
-
-      private
+      def to_value
+        if children.any?
+          (options[:config_class] || Config).new(children)
+        else
+          value = default
+          value = constructor.(value) unless value.eql?(Undefined)
 
-      # @api private
-      def initialize_copy(source)
-        super
-        @value = source.value.dup if source.input_defined? && source.clonable_value?
-        @options = source.options.dup
-      end
-
-      # @api private
-      def evaluate
-        @value = constructor[input.equal?(Undefined) ? nil : input]
+          mutable? ? value.dup : value
+        end
       end
     end
   end