dry-configurable 0.8.2 → 0.11.2

data/lib/dry/configurable/dsl/args.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'dry/configurable/constants'
+require 'dry/configurable/setting'
+
+module Dry
+  module Configurable
+    class DSL
+      # @api private
+      class Args
+        # @api private
+        attr_reader :args
+
+        # @api private
+        attr_reader :size
+
+        # @api private
+        attr_reader :opts
+
+        # @api private
+        def initialize(args)
+          @args = args
+          @size = args.size
+          @opts = Setting::OPTIONS
+        end
+
+        # @api private
+        def ensure_valid_options
+          return unless options
+
+          keys = options.keys - opts
+          raise ArgumentError, "Invalid options: #{keys.inspect}" unless keys.empty?
+        end
+
+        # @api private
+        def to_ary
+          [default, options || EMPTY_HASH]
+        end
+
+        # @api private
+        def default
+          if size.equal?(1) && options.nil?
+            args[0]
+          elsif size > 1 && options
+            args[0]
+          else
+            Undefined
+          end
+        end
+
+        # @api private
+        def options
+          args.detect { |arg| arg.is_a?(Hash) && (opts & arg.keys).any? }
+        end
+      end
+    end
+  end
+end

data/lib/dry/configurable/{error.rb → errors.rb}

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 module Dry
+  # Shared errors
+  #
+  # @api public
   module Configurable
     Error = Class.new(::StandardError)
-    AlreadyDefinedConfig = ::Class.new(Error)
     FrozenConfig = ::Class.new(Error)
   end
 end

data/lib/dry/configurable/instance_methods.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'dry/configurable/config'
+require 'dry/configurable/methods'
+
+module Dry
+  module Configurable
+    # Instance-level API when `Dry::Configurable` is included in a class
+    #
+    # @api public
+    module InstanceMethods
+      include Methods
+
+      # Return object's configuration
+      #
+      # @return [Config]
+      #
+      # @api public
+      attr_reader :config
+
+      # @api private
+      def initialize(*)
+        @config = Config.new(self.class._settings.dup)
+        super
+      end
+
+      # Finalize the config and freeze the object
+      #
+      # @api public
+      def finalize!
+        return self if frozen?
+
+        super
+        freeze
+      end
+
+      private
+
+      # @api public
+      def initialize_copy(source)
+        super
+        @config = source.config.dup
+      end
+    end
+  end
+end

data/lib/dry/configurable/methods.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'dry/configurable/errors'
+
+module Dry
+  module Configurable
+    # Common API for both classes and instances
+    #
+    # @api public
+    module Methods
+      # @api public
+      def configure(&block)
+        raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+
+        yield(config) if block
+        self
+      end
+
+      # Finalize and freeze configuration
+      #
+      # @return [Dry::Configurable::Config]
+      #
+      # @api public
+      def finalize!
+        return self if config.frozen?
+
+        config.finalize!
+        self
+      end
+    end
+  end
+end

data/lib/dry/configurable/setting.rb

@@ -1,36 +1,119 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require 'dry/equalizer'
+
+require 'dry/configurable/constants'
+require 'dry/configurable/config'
+
 module Dry
   module Configurable
     # This class represents a setting and is used internally.
     #
-    # @private
+    # @api private
     class Setting
+      include Dry::Equalizer(:name, :value, :options)
+
+      OPTIONS = %i[input default reader constructor settings].freeze
+
+      DEFAULT_CONSTRUCTOR = -> v { v }.freeze
+
+      CLONABLE_VALUE_TYPES = [Array, Hash, Set, Config].freeze
+
+      # @api private
       attr_reader :name
 
+      # @api private
+      attr_reader :writer_name
+
+      # @api private
+      attr_reader :input
+
+      # @api private
+      attr_reader :default
+
+      # @api private
       attr_reader :options
 
-      attr_reader :processor
+      # 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
+      end
 
-      def initialize(name, value, processor, options = EMPTY_HASH)
-        @name = name.to_sym
-        @value = value
-        @processor = processor
+      # @api private
+      def initialize(name, input: Undefined, default: Undefined, **options)
+        @name = name
+        @writer_name = :"#{name}="
+        @input = input.equal?(Undefined) ? default : input
+        @default = default
         @options = options
       end
 
+      # @api private
       def value
-        Undefined.default(@value, nil)
+        @value ||= evaluate
       end
 
-      def undefined?
-        Undefined.equal?(@value)
+      # @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
       def reader?
-        options[:reader]
+        options[:reader].equal?(true)
+      end
+
+      # @api private
+      def writer?(meth)
+        writer_name.equal?(meth)
+      end
+
+      # @api private
+      def clonable_value?
+        CLONABLE_VALUE_TYPES.any? { |type| value.is_a?(type) }
+      end
+
+      private
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @value = source.value.dup if source.clonable_value?
+        @options = source.options.dup
       end
 
-      def node?
-        Settings === @value
+      # @api private
+      def evaluate
+        @value = constructor[input.equal?(Undefined) ? nil : input]
       end
     end
   end

data/lib/dry/configurable/settings.rb

@@ -1,91 +1,71 @@
-require 'set'
-require 'concurrent/array'
-require 'dry/configurable/settings/argument_parser'
-require 'dry/configurable/setting'
-require 'dry/configurable/config'
+# frozen_string_literal: true
+
+require 'concurrent/map'
+
+require 'dry/equalizer'
+require 'dry/configurable/constants'
 
 module Dry
   module Configurable
-    # A collection of settings. This is not part of the public API.
+    # A settings map
     #
-    # @private
+    # @api private
     class Settings
-      Parser = ArgumentParser.new.freeze
+      include Dry::Equalizer(:elements)
 
-      class DSL
-        def self.call(&block)
-          new.instance_exec do
-            instance_exec(&block)
-            @settings
-          end
-        end
+      include Enumerable
 
-        def initialize
-          @settings = Settings.new
-        end
+      # @api private
+      attr_reader :elements
 
-        def setting(*args, &block)
-          @settings.add(*args, &block)
-        end
+      # @api private
+      def initialize(elements = EMPTY_ARRAY)
+        initialize_elements(elements)
       end
 
-      # Capture nested config definition
-      #
-      # @return [Dry::Configurable::Setting]
-      def self.capture(&block)
-        DSL.(&block)
+      # @api private
+      def <<(setting)
+        elements[setting.name] = setting
+        self
       end
 
-      attr_reader :settings
-
-      attr_reader :config_class
-
-      attr_reader :names
-
-      def initialize(settings = ::Concurrent::Array.new)
-        @settings = settings
-        @config_class = Config[self]
-        @names = Set.new(settings.map(&:name))
-        yield(self) if block_given?
+      # @api private
+      def [](name)
+        elements[name]
       end
 
-      def add(key, value = Undefined, options = Undefined, &block)
-        extended = singleton_class < Configurable
-        raise_already_defined_config(key) if extended && configured?
-
-        Setting.new(key, *Parser.(value, options, block)).tap do |s|
-          settings << s
-          names << s.name
-        end
-      end
-
-      def each
-        settings.each { |s| yield(s) }
+      # @api private
+      def key?(name)
+        keys.include?(name)
       end
 
-      def empty?
-        settings.empty?
+      # @api private
+      def keys
+        elements.keys
       end
 
-      def name?(name)
-        names.include?(name)
+      # @api private
+      def each(&block)
+        elements.values.each(&block)
       end
 
-      def dup
-        Settings.new(settings.dup)
+      # @api private
+      def pristine
+        self.class.new(map(&:pristine))
       end
 
-      def freeze
-        settings.freeze
-        super
-      end
+      private
 
-      def create_config
-        config_class.new
+      # @api private
+      def initialize_copy(source)
+        initialize_elements(source.map(&:dup))
       end
 
-      def config_defined?
-        config_class.config_defined?
+      # @api private
+      def initialize_elements(elements)
+        @elements = elements.each_with_object(Concurrent::Map.new) { |s, m|
+          m[s.name] = s
+        }
       end
     end
   end

data/lib/dry/configurable/test_interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dry
   module Configurable
     # Methods meant to be used in a testing scenario
@@ -8,11 +10,7 @@ module Dry
       #
       # @api public
       def reset_config
-        @config = if self.is_a?(Module)
-                    _settings.create_config
-                  else
-                    self.class._settings.create_config
-                  end
+        @config = config.pristine
       end
     end
 

data/lib/dry/configurable/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Dry
   module Configurable
     # @api public
-    VERSION = '0.8.2'.freeze
+    VERSION = '0.11.2'
   end
 end