dry-configurable 0.9.0 → 0.11.3

data/lib/dry/configurable/class_methods.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'set'
+
+require 'dry/configurable/constants'
+require 'dry/configurable/dsl'
+require 'dry/configurable/methods'
+require 'dry/configurable/settings'
+
+module Dry
+  module Configurable
+    module ClassMethods
+      include Methods
+
+      # @api private
+      def inherited(klass)
+        super
+
+        parent_settings = (respond_to?(:config) ? config._settings : _settings)
+
+        klass.instance_variable_set('@_settings', parent_settings)
+      end
+
+      # Add a setting to the configuration
+      #
+      # @param [Mixed] key
+      #   The accessor key for the configuration value
+      # @param [Mixed] default
+      #   The default config value
+      #
+      # @yield
+      #   If a block is given, it will be evaluated in the context of
+      #   a new configuration class, and bound as the default value
+      #
+      # @return [Dry::Configurable::Config]
+      #
+      # @api public
+      def setting(*args, &block)
+        setting = __config_dsl__.setting(*args, &block)
+
+        _settings << setting
+
+        __config_reader__.define(setting.name) if setting.reader?
+
+        self
+      end
+
+      # Return declared settings
+      #
+      # @return [Set<Symbol>]
+      #
+      # @api public
+      def settings
+        @settings ||= Set[*_settings.map(&:name)]
+      end
+
+      # Return declared settings
+      #
+      # @return [Settings]
+      #
+      # @api public
+      def _settings
+        @_settings ||= Settings.new
+      end
+
+      # Return configuration
+      #
+      # @return [Config]
+      #
+      # @api public
+      def config
+        @config ||= Config.new(_settings)
+      end
+
+      # @api private
+      def __config_dsl__
+        @dsl ||= DSL.new
+      end
+
+      # @api private
+      def __config_reader__
+        @__config_reader__ ||=
+          begin
+            reader = Module.new do
+              def self.define(name)
+                define_method(name) do
+                  config[name]
+                end
+              end
+            end
+
+            if included_modules.include?(InstanceMethods)
+              include(reader)
+            end
+
+            extend(reader)
+
+            reader
+          end
+      end
+    end
+  end
+end

data/lib/dry/configurable/compiler.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'dry/configurable/setting'
+require 'dry/configurable/settings'
+
+module Dry
+  module Configurable
+    # Setting compiler used internally by the DSL
+    #
+    # @api private
+    class Compiler
+      def call(ast)
+        Settings.new.tap do |settings|
+          ast.each do |node|
+            settings << visit(node)
+          end
+        end
+      end
+
+      # @api private
+      def visit(node)
+        type, rest = node
+        public_send(:"visit_#{type}", rest)
+      end
+
+      # @api private
+      def visit_constructor(node)
+        setting, constructor = node
+        visit(setting).with(constructor: constructor)
+      end
+
+      # @api private
+      def visit_setting(node)
+        name, default, opts = node
+        Setting.new(name, **opts, default: default)
+      end
+
+      # @api private
+      def visit_nested(node)
+        parent, children = node
+        visit(parent).nested(call(children))
+      end
+    end
+  end
+end

data/lib/dry/configurable/config.rb

@@ -1,112 +1,42 @@
-require 'concurrent/hash'
+# frozen_string_literal: true
 
-module Dry
-  module Configurable
-    # @private
-    class Config
-      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
-
-        # @private
-        def define_accessors!
-          @lock.synchronize do
-            break if config_defined?
-
-            settings.each do |setting|
-              next if setting.reserved?
-
-              define_method(setting.name) do
-                @config[setting.name]
-              end
-
-              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
-
-        # @private
-        def config_defined?
-          @config_defined
-        end
-      end
-
-      def initialize
-        @config = ::Concurrent::Hash.new
-        @lock = ::Mutex.new
-        @defined = false
-      end
+require 'concurrent/map'
 
-      def defined?
-        @defined
-      end
+require 'dry/equalizer'
 
-      # @private
-      def define!(parent_config = EMPTY_HASH)
-        @lock.synchronize do
-          break if self.defined?
+require 'dry/configurable/constants'
+require 'dry/configurable/errors'
 
-          self.class.define_accessors!
-          set_values!(parent_config)
+module Dry
+  module Configurable
+    # Config exposes setting values through a convenient API
+    #
+    # @api public
+    class Config
+      include Dry::Equalizer(:values)
 
-          @defined = true
-        end
+      # @api private
+      attr_reader :_settings
 
-        self
-      end
+      # @api private
+      attr_reader :_resolved
 
-      # @private
-      def finalize!
-        define!
-        @config.freeze
-        freeze
+      # @api private
+      def initialize(settings)
+        @_settings = settings.dup
+        @_resolved = Concurrent::Map.new
       end
 
-      # Serialize config to a Hash
-      #
-      # @return [Hash]
-      #
-      # @api public
-      def to_h
-        @config.each_with_object({}) do |(key, value), hash|
-          case value
-          when Config
-            hash[key] = value.to_h
-          else
-            hash[key] = value
-          end
-        end
-      end
-      alias to_hash to_h
-
       # Get config value by a key
       #
       # @param [String,Symbol] name
       #
       # @return Config value
       def [](name)
-        setting = self.class.settings[name.to_sym]
+        name = name.to_sym
+        raise ArgumentError, "+#{name}+ is not a setting name" unless _settings.key?(name)
 
-        if setting.nil?
-          raise_unknown_setting_error(name)
-        elsif setting.reserved?
-          @config[setting.name]
-        else
-          public_send(name)
-        end
+        _settings[name].value
       end
 
       # Set config value.
@@ -115,70 +45,83 @@ module Dry
       # @param [String,Symbol] name
       # @param [Object] value
       def []=(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
+        public_send(:"#{name}=", value)
       end
 
-      # Whether config has a key
+      # Update config with new values
       #
-      # @param [Symbol] key
-      # @return [Bool]
-      def key?(name)
-        self.class.settings.name?(name)
-      end
-
-      # Recursively update values from a hash
+      # @param [Hash] A hash with new values
       #
-      # @param [Hash] values to set
       # @return [Config]
+      #
+      # @api public
       def update(values)
         values.each do |key, value|
-          if self[key].is_a?(Config)
+          case value
+          when Hash
             self[key].update(value)
           else
             self[key] = value
           end
         end
-        self
       end
 
-      def dup
-        if self.defined?
-          self.class.new.define!(to_h)
-        else
-          self.class.new
-        end
+      # Dump config into a hash
+      #
+      # @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
+      end
+      alias_method :to_h, :values
+      alias_method :to_hash, :values
+
+      # @api private
+      def finalize!
+        _settings.freeze
+        freeze
+      end
+
+      # @api private
+      def pristine
+        self.class.new(_settings.pristine)
+      end
+
+      # @api private
+      def respond_to_missing?(meth, include_private = false)
+        super || _settings.key?(resolve(meth))
       end
 
       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
+      # @api private
+      def method_missing(meth, *args)
+        setting = _settings[resolve(meth)]
+
+        super unless setting
+
+        if setting.writer?(meth)
+          raise FrozenConfig, 'Cannot modify frozen config' if frozen?
+
+          _settings << setting.with(input: args[0])
+        else
+          setting.value
         end
       end
 
-      # @private
-      def raise_unknown_setting_error(name)
-        ::Kernel.raise ArgumentError, "+#{name}+ is not a setting name"
+      # @api private
+      def resolve(meth)
+        _resolved.fetch(meth) { _resolved[meth] = meth.to_s.tr('=', '').to_sym }
+      end
+
+      # @api private
+      def initialize_copy(source)
+        super
+        @_settings = source._settings.dup
       end
     end
   end

data/lib/dry/configurable/constants.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'dry/core/constants'
+
+module Dry
+  # Shared constants
+  #
+  # @api private
+  module Configurable
+    include Dry::Core::Constants
+  end
+end

data/lib/dry/configurable/dsl.rb

@@ -0,0 +1,62 @@
+# 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
+    #
+    # @api private
+    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)
+        @compiler = Compiler.new
+        @ast = []
+        instance_exec(&block) if block
+      end
+
+      # Register a new setting node and compile it into a setting object
+      #
+      # @see ClassMethods.setting
+      # @api public
+      # @return Setting
+      def setting(name, *args, &block)
+        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
+
+        default, opts = args
+
+        node = [:setting, [name.to_sym, default, opts == default ? EMPTY_HASH : opts]]
+
+        if block
+          if block.arity.zero?
+            ast << [:nested, [node, DSL.new(&block).ast]]
+          else
+            ast << [:constructor, [node, block]]
+          end
+        else
+          ast << node
+        end
+
+        compiler.visit(ast.last)
+      end
+    end
+  end
+end