dry-configurable 0.8.0 → 0.11.0

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,103 +1,41 @@
-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|
-              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
+require 'concurrent/map'
 
-            @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 'dry/equalizer'
 
-      def defined?
-        @defined
-      end
+require 'dry/configurable/constants'
+require 'dry/configurable/errors'
 
-      # @private
-      def define!(parent_config = EMPTY_HASH)
-        @lock.synchronize do
-          break if self.defined?
-
-          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)
-        raise_unknown_setting_error(name) unless key?(name.to_sym)
-        public_send(name)
+        raise ArgumentError, "+#{name}+ is not a setting name" unless settings.key?(name)
+
+        settings[name].value
       end
 
       # Set config value.
@@ -106,55 +44,83 @@ module Dry
       # @param [String,Symbol] name
       # @param [Object] value
       def []=(name, value)
-        raise_unknown_setting_error(name) unless key?(name.to_sym)
-        public_send("#{name}=", value)
+        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
+
+      # 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)
-        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, 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

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