dry-configurable 0.9.0 → 0.11.4

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,45 +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
-      VALID_NAME = /\A[a-z_]\w*\z/i
+      include Dry::Equalizer(:name, :value, :options, inspect: false)
+
+      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)
 
-      def initialize(name, value, processor, options = EMPTY_HASH)
-        unless VALID_NAME =~ name.to_s
-          raise ArgumentError, "+#{name}+ is not a valid setting name"
+        # @api private
+        def pristine
+          with(input: input.pristine)
         end
-        @name = name.to_sym
-        @value = value
-        @processor = processor
+
+        # @api private
+        def constructor
+          CONSTRUCTOR
+        end
+      end
+
+      # @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
+
+      # @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
 
-      def undefined?
-        Undefined.equal?(@value)
+      # @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
 
-      def node?
-        Settings === @value
+      # @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 reserved?
-        options[:reserved]
+      # @api private
+      def evaluate
+        @value = constructor[input.equal?(Undefined) ? nil : input]
       end
     end
   end

data/lib/dry/configurable/settings.rb

@@ -1,116 +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
-
-      class DSL
-        def self.call(&block)
-          new.instance_exec do
-            instance_exec(&block)
-            @settings
-          end
-        end
-
-        def initialize
-          @settings = Settings.new
-        end
-
-        def setting(*args, &block)
-          @settings.add(*args, &block)
-        end
-      end
-
-      # Capture nested config definition
-      #
-      # @return [Dry::Configurable::Setting]
-      def self.capture(&block)
-        DSL.(&block)
-      end
-
-      attr_reader :settings
+      include Dry::Equalizer(:elements)
 
-      attr_reader :config_class
+      include Enumerable
 
-      attr_reader :index
-      private :index
+      # @api private
+      attr_reader :elements
 
-      def initialize(settings = ::Concurrent::Array.new)
-        @settings = settings
-        @config_class = Config[self]
-        @index = settings.map { |s| [s.name, s] }.to_h
-        yield(self) if block_given?
+      # @api private
+      def initialize(elements = EMPTY_ARRAY)
+        initialize_elements(elements)
       end
 
-      def add(key, value = Undefined, options = Undefined, &block)
-        extended = singleton_class < Configurable
-        raise_already_defined_config(key) if extended && configured?
-
-        *args, opts = Parser.(value, options, block)
-
-        Setting.new(key, *args, { **opts, reserved: reserved?(key) }).tap do |s|
-          settings.delete_if { |e| e.name.eql?(s.name) }
-          settings << s
-          index[s.name] = s
-          @names = nil
-        end
-      end
-
-      def each
-        settings.each { |s| yield(s) }
-      end
-
-      def names
-        @names ||= index.keys.to_set
+      # @api private
+      def <<(setting)
+        elements[setting.name] = setting
+        self
       end
 
+      # @api private
       def [](name)
-        index[name]
-      end
-
-      def empty?
-        settings.empty?
+        elements[name]
       end
 
-      def name?(name)
-        index.key?(name)
+      # @api private
+      def key?(name)
+        keys.include?(name)
       end
 
-      def dup
-        Settings.new(settings.dup)
+      # @api private
+      def keys
+        elements.keys
       end
 
-      def freeze
-        settings.freeze
-        super
+      # @api private
+      def each(&block)
+        elements.values.each(&block)
       end
 
-      def create_config
-        config_class.new
+      # @api private
+      def pristine
+        self.class.new(map(&:pristine))
       end
 
-      def config_defined?
-        config_class.config_defined?
-      end
+      private
 
-      def reserved?(name)
-        reserved_names.include?(name)
+      # @api private
+      def initialize_copy(source)
+        initialize_elements(source.map(&:dup))
       end
 
-      def reserved_names
-        @reserved_names ||= [
-          config_class.instance_methods(false),
-          config_class.superclass.instance_methods(false),
-          %i(class public_send)
-        ].reduce(:+)
+      # @api private
+      def initialize_elements(elements)
+        @elements = elements.each_with_object(Concurrent::Map.new) { |s, m|
+          m[s.name] = s
+        }
       end
     end
   end