dry-configurable 0.7.0 → 0.9.0

data/lib/dry/configurable/config.rb

@@ -1,61 +1,89 @@
+require 'concurrent/hash'
+
 module Dry
   module Configurable
     # @private
     class Config
-      DEFAULT_PROCESSOR = ->(v) { v }.freeze
+      class << self
+        # @private
+        def [](settings)
+          ::Class.new(Config) do
+            @settings = settings
+            singleton_class.send(:attr_reader, :settings)
+
+            @lock = ::Mutex.new
+            @config_defined = false
+          end
+        end
 
-      def self.create(settings)
-        klass = ::Class.new(self)
+        # @private
+        def define_accessors!
+          @lock.synchronize do
+            break if config_defined?
 
-        settings.each do |setting|
-          klass.__send__(:define_method, setting.name) do
-            @config[setting.name]
-          end
+            settings.each do |setting|
+              next if setting.reserved?
+
+              define_method(setting.name) do
+                @config[setting.name]
+              end
 
-          klass.__send__(:define_method, "#{setting.name}=") do |value|
-            raise_frozen_config if frozen?
-            @config[setting.name] = setting.processor.call(value)
+              define_method("#{setting.name}=") do |value|
+                raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+                @config[setting.name] = setting.processor.(value)
+              end
+            end
+
+            @config_defined = true
           end
         end
 
-        klass.new(settings)
+        # @private
+        def config_defined?
+          @config_defined
+        end
       end
 
-      def initialize(settings)
+      def initialize
         @config = ::Concurrent::Hash.new
-
-        settings.each do |setting|
-          if setting.none?
-            @config[setting.name] = nil
-          else
-            public_send("#{setting.name}=", setting.value)
-          end
-        end
+        @lock = ::Mutex.new
+        @defined = false
       end
 
-      def dup
-        dup = super
-        dup.instance_variable_set(:@config, @config.dup)
-        dup
+      def defined?
+        @defined
       end
 
-      def clone
-        clone = super
-        clone.instance_variable_set(:@config, @config.clone)
-        clone
+      # @private
+      def define!(parent_config = EMPTY_HASH)
+        @lock.synchronize do
+          break if self.defined?
+
+          self.class.define_accessors!
+          set_values!(parent_config)
+
+          @defined = true
+        end
+
+        self
       end
 
+      # @private
       def finalize!
+        define!
         @config.freeze
         freeze
       end
 
+      # Serialize config to a Hash
+      #
+      # @return [Hash]
+      #
+      # @api public
       def to_h
-        @config.each_with_object({}) do |tuple, hash|
-          key, value = tuple
-
+        @config.each_with_object({}) do |(key, value), hash|
           case value
-          when ::Dry::Configurable::Config, ::Dry::Configurable::NestedConfig
+          when Config
             hash[key] = value.to_h
           else
             hash[key] = value
@@ -64,28 +92,93 @@ module Dry
       end
       alias to_hash to_h
 
+      # Get config value by a key
+      #
+      # @param [String,Symbol] name
+      #
+      # @return Config value
       def [](name)
-        raise_unknown_setting_error(name) unless setting?(name)
-        public_send(name)
+        setting = self.class.settings[name.to_sym]
+
+        if setting.nil?
+          raise_unknown_setting_error(name)
+        elsif setting.reserved?
+          @config[setting.name]
+        else
+          public_send(name)
+        end
       end
 
+      # Set config value.
+      # Note that finalized configs cannot be changed.
+      #
+      # @param [String,Symbol] name
+      # @param [Object] value
       def []=(name, value)
-        raise_unknown_setting_error(name) unless setting?(name)
-        public_send("#{name}=", value)
+        setting = self.class.settings[name.to_sym]
+
+        if setting.nil?
+          raise_unknown_setting_error(name)
+        elsif setting.reserved?
+          @config[setting.name] = setting.processor.(value)
+        else
+          public_send("#{name}=", value)
+        end
       end
 
-      private
+      # Whether config has a key
+      #
+      # @param [Symbol] key
+      # @return [Bool]
+      def key?(name)
+        self.class.settings.name?(name)
+      end
 
-      def raise_frozen_config
-        raise FrozenConfig, 'Cannot modify frozen config'
+      # Recursively update values from a hash
+      #
+      # @param [Hash] values to set
+      # @return [Config]
+      def update(values)
+        values.each do |key, value|
+          if self[key].is_a?(Config)
+            self[key].update(value)
+          else
+            self[key] = value
+          end
+        end
+        self
       end
 
-      def raise_unknown_setting_error(name)
-        raise ArgumentError, "+#{name}+ is not a setting name"
+      def dup
+        if self.defined?
+          self.class.new.define!(to_h)
+        else
+          self.class.new
+        end
       end
 
-      def setting?(name)
-        @config.key?(name.to_sym)
+      private
+
+      # @private
+      def set_values!(parent)
+        self.class.settings.each do |setting|
+          if parent.key?(setting.name) && !setting.node?
+            @config[setting.name] = parent[setting.name]
+          elsif setting.undefined?
+            @config[setting.name] = nil
+          elsif setting.node?
+            value = setting.value.create_config
+            value.define!(parent.fetch(setting.name, EMPTY_HASH))
+            self[setting.name] = value
+          else
+            self[setting.name] = setting.value
+          end
+        end
+      end
+
+      # @private
+      def raise_unknown_setting_error(name)
+        ::Kernel.raise ArgumentError, "+#{name}+ is not a setting name"
       end
     end
   end

data/lib/dry/configurable/error.rb

@@ -1,5 +1,3 @@
-# A collection of micro-libraries, each intended to encapsulate
-# a common task in Ruby
 module Dry
   module Configurable
     Error = Class.new(::StandardError)

data/lib/dry/configurable/setting.rb

@@ -0,0 +1,46 @@
+module Dry
+  module Configurable
+    # This class represents a setting and is used internally.
+    #
+    # @private
+    class Setting
+      VALID_NAME = /\A[a-z_]\w*\z/i
+
+      attr_reader :name
+
+      attr_reader :options
+
+      attr_reader :processor
+
+      def initialize(name, value, processor, options = EMPTY_HASH)
+        unless VALID_NAME =~ name.to_s
+          raise ArgumentError, "+#{name}+ is not a valid setting name"
+        end
+        @name = name.to_sym
+        @value = value
+        @processor = processor
+        @options = options
+      end
+
+      def value
+        Undefined.default(@value, nil)
+      end
+
+      def undefined?
+        Undefined.equal?(@value)
+      end
+
+      def reader?
+        options[:reader]
+      end
+
+      def node?
+        Settings === @value
+      end
+
+      def reserved?
+        options[:reserved]
+      end
+    end
+  end
+end

data/lib/dry/configurable/settings.rb

@@ -0,0 +1,117 @@
+require 'set'
+require 'concurrent/array'
+require 'dry/configurable/settings/argument_parser'
+require 'dry/configurable/setting'
+require 'dry/configurable/config'
+
+module Dry
+  module Configurable
+    # A collection of settings. This is not part of the public 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
+
+      attr_reader :config_class
+
+      attr_reader :index
+      private :index
+
+      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?
+      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
+      end
+
+      def [](name)
+        index[name]
+      end
+
+      def empty?
+        settings.empty?
+      end
+
+      def name?(name)
+        index.key?(name)
+      end
+
+      def dup
+        Settings.new(settings.dup)
+      end
+
+      def freeze
+        settings.freeze
+        super
+      end
+
+      def create_config
+        config_class.new
+      end
+
+      def config_defined?
+        config_class.config_defined?
+      end
+
+      def reserved?(name)
+        reserved_names.include?(name)
+      end
+
+      def reserved_names
+        @reserved_names ||= [
+          config_class.instance_methods(false),
+          config_class.superclass.instance_methods(false),
+          %i(class public_send)
+        ].reduce(:+)
+      end
+    end
+  end
+end

data/lib/dry/configurable/settings/argument_parser.rb

@@ -0,0 +1,50 @@
+module Dry
+  # Argument parser
+  #
+  # Passing and array or arguments, it will decide which one are arguments
+  # and which one are options.
+  #
+  # We have a limitation if setting the value without options, as a hash
+  # having the same key as one of the valid options, will parse the value
+  # as options. In this case, all unknown options will be reject with an exception.
+  #
+  # @example
+  #   p = Dry::Configurable::ArgumentParser.new.('db:sqlite', reader: true)
+  #
+  #   p[0] # => 'db:sqlite'
+  #   p[1] # => ArgumentParser::DEFAULT_PROCESSOR
+  #   p[2] # => { reader: true }
+  module Configurable
+    class Settings
+      # @private
+      class ArgumentParser
+        DEFAULT_PROCESSOR = ->(v) { v }
+
+        # @private
+        def call(val, opts, block)
+          if block && block.parameters.empty?
+            raise ArgumentError unless Undefined.equal?(opts)
+
+            processor = DEFAULT_PROCESSOR
+
+            value, options = Settings.capture(&block), val
+          else
+            processor = block || DEFAULT_PROCESSOR
+
+            if Undefined.equal?(opts) && val.is_a?(Hash) && val.key?(:reader)
+              value, options = Undefined, val
+            else
+              value, options = val, opts
+            end
+          end
+
+          [value, processor, options(**Undefined.default(options, EMPTY_HASH))]
+        end
+
+        def options(reader: false)
+          { reader: reader }
+        end
+      end
+    end
+  end
+end

data/lib/dry/configurable/test_interface.rb

@@ -8,7 +8,11 @@ module Dry
       #
       # @api public
       def reset_config
-        create_config
+        @config = if self.is_a?(Module)
+                    _settings.create_config
+                  else
+                    self.class._settings.create_config
+                  end
       end
     end