dry-initializer 1.4.1 → 2.0.0

data/lib/dry/initializer/attribute.rb

@@ -1,123 +0,0 @@
-module Dry::Initializer
-  # Contains definitions for a single attribute, and builds its parts of mixin
-  class Attribute
-    class << self
-      # Collection of additional dispatchers for method options
-      #
-      # @example Enhance the gem by adding :coercer alias for type
-      #   Dry::Initializer::Attribute.dispatchers << -> (string: nil, **op) do
-      #     op[:type] = proc(&:to_s) if string
-      #     op
-      #   end
-      #
-      #   class User
-      #     extend Dry::Initializer
-      #     param :name, string: true # same as `type: proc(&:to_s)`
-      #   end
-      #
-      def dispatchers
-        @@dispatchers ||= []
-      end
-
-      def new(source, coercer = nil, **options)
-        options[:source] = source
-        options[:target] = options.delete(:as) || source
-        options[:type] ||= coercer
-        params = dispatchers.inject(options) { |h, m| m.call(h) }
-
-        super(params)
-      end
-
-      def param(*args)
-        Param.new(*args)
-      end
-
-      def option(*args)
-        Option.new(*args)
-      end
-    end
-
-    attr_reader :source, :target, :coercer, :default, :optional, :reader
-
-    def initialize(options)
-      @source    = options[:source]
-      @target    = options[:target]
-      @coercer   = options[:type]
-      @default   = options[:default]
-      @optional  = !!(options[:optional] || @default)
-      @reader    = options.fetch(:reader, :public)
-      @undefined = options.fetch(:undefined, true)
-      validate
-    end
-
-    def ==(other)
-      source == other.source
-    end
-
-    def postsetter
-      "@__options__[:#{target}] = @#{target}" \
-      " unless @#{target} == #{undefined}"
-    end
-
-    def getter
-      return unless reader
-      command = %w(private protected).include?(reader.to_s) ? reader : :public
-
-      <<-RUBY
-        undef_method :#{target} if method_defined?(:#{target}) ||
-                                   protected_method_defined?(:#{target}) ||
-                                   private_method_defined?(:#{target})
-        #{reader_definition}
-        #{command} :#{target}
-      RUBY
-    end
-
-    private
-
-    def validate
-      validate_target
-      validate_default
-      validate_coercer
-    end
-
-    def undefined
-      @undefined ? "Dry::Initializer::UNDEFINED" : "nil"
-    end
-
-    def reader_definition
-      if @undefined
-        "def #{target}; @#{target} unless @#{target} == #{undefined}; end"
-      else
-        "attr_reader :#{target}"
-      end
-    end
-
-    def validate_target
-      return if target =~ /\A\w+\Z/
-      fail ArgumentError.new("Invalid name '#{target}' for the target variable")
-    end
-
-    def validate_default
-      return if default.nil? || default.is_a?(Proc)
-      fail DefaultValueError.new(source, default)
-    end
-
-    def validate_coercer
-      return if coercer.nil? || coercer.respond_to?(:call)
-      fail TypeConstraintError.new(source, coercer)
-    end
-
-    def default_hash(type)
-      default ? { :"#{type}_#{source}" => default } : {}
-    end
-
-    def coercer_hash(type)
-      return {} unless coercer
-
-      value = coercer unless @undefined
-      value ||= proc { |v| v == Dry::Initializer::UNDEFINED ? v : coercer.(v) }
-
-      { :"#{type}_#{source}" => value }
-    end
-  end
-end

data/lib/dry/initializer/builder.rb

@@ -1,127 +0,0 @@
-module Dry::Initializer
-  class Builder
-    def param(*args, **opts)
-      @params = insert @params, Attribute.param(*args, **@config.merge(opts))
-      validate_collections
-    end
-
-    def option(*args, **opts)
-      @options = insert @options, Attribute.option(*args, **@config.merge(opts))
-      validate_collections
-    end
-
-    def call(mixin)
-      clear_method(mixin, :__defaults__)
-      clear_method(mixin, :__coercers__)
-      clear_method(mixin, :__initialize__)
-
-      defaults = send(:defaults)
-      coercers = send(:coercers)
-
-      mixin.send(:define_method, :__defaults__) { defaults }
-      mixin.send(:define_method, :__coercers__) { coercers }
-      mixin.class_eval(code)
-    end
-
-    private
-
-    def initialize(**config)
-      @config  = config
-      @params  = []
-      @options = []
-    end
-
-    def insert(collection, new_item)
-      index = collection.index(new_item) || collection.count
-      collection.dup.tap { |list| list[index] = new_item }
-    end
-
-    def clear_method(mixin, name)
-      mixin.send(:undef_method, name) if mixin.private_method_defined? name
-    end
-
-    def code
-      <<-RUBY
-        def __initialize__(#{initializer_signatures})
-          @__options__ = {}
-        #{initializer_presetters}
-        #{initializer_setters}
-        #{initializer_postsetters}
-        end
-        private :__initialize__
-        private :__defaults__
-        private :__coercers__
-
-        #{getters}
-      RUBY
-    end
-
-    def attributes
-      @params + @options
-    end
-
-    def duplications
-      attributes.group_by(&:target)
-                .reject { |_, val| val.count == 1 }
-                .keys
-    end
-
-    def initializer_signatures
-      sig = @params.map(&:initializer_signature).compact.uniq
-      sig << (sig.any? && @options.any? ? "**__options__" : "__options__ = {}")
-      sig.join(", ")
-    end
-
-    def initializer_presetters
-      dups = duplications
-      attributes.map { |a| "  #{a.presetter}" if dups.include? a.target }
-                .compact.uniq.join("\n")
-    end
-
-    def initializer_setters
-      dups = duplications
-      attributes.map do |a|
-        dups.include?(a.target) ? "  #{a.safe_setter}" : "  #{a.fast_setter}"
-      end.compact.uniq.join("\n")
-    end
-
-    def initializer_postsetters
-      attributes.map { |a| "  #{a.postsetter}" }.compact.uniq.join("\n")
-    end
-
-    def defined_options
-      if @options.any?
-        keys = @options.map(&:target).join(" ")
-        "__options__.select { |key| %i(#{keys}).include? key }"
-      else
-        "{}"
-      end
-    end
-
-    def getters
-      attributes.map(&:getter).compact.uniq.join("\n")
-    end
-
-    def defaults
-      attributes.map(&:default_hash).reduce({}, :merge)
-    end
-
-    def coercers
-      attributes.map(&:coercer_hash).reduce({}, :merge)
-    end
-
-    def validate_collections
-      optional_param = nil
-
-      @params.each do |param|
-        if param.optional
-          optional_param = param.source if param.optional
-        elsif optional_param
-          fail ParamsOrderError.new(param.source, optional_param)
-        end
-      end
-
-      self
-    end
-  end
-end

data/lib/dry/initializer/class_dsl.rb

@@ -1,37 +0,0 @@
-module Dry::Initializer
-  module ClassDSL
-    attr_reader :config
-
-    def [](**settings)
-      Module.new do
-        extend  Dry::Initializer::ClassDSL
-        include Dry::Initializer
-        @config = settings
-      end
-    end
-
-    def define(fn = nil, &block)
-      mixin   = Module.new { include InstanceDSL }
-      builder = Builder.new Hash(config)
-      builder.instance_exec(&(fn || block))
-      builder.call(mixin)
-      mixin
-    end
-
-    private
-
-    def extended(klass)
-      super
-      mixin   = klass.send(:__initializer_mixin__)
-      builder = klass.send(:__initializer_builder__, Hash(config))
-      builder.call(mixin)
-
-      klass.include(InstanceDSL) # defines #initialize
-      klass.include(mixin)       # defines #__initialize__ (to be redefined)
-    end
-
-    def mixin(fn = nil, &block)
-      define(fn, &block)
-    end
-  end
-end

data/lib/dry/initializer/exceptions/default_value_error.rb

@@ -1,8 +0,0 @@
-module Dry::Initializer
-  class DefaultValueError < TypeError
-    def initialize(name, value)
-      super "Cannot set #{value.inspect} directly as a default value" \
-            " of the argument '#{name}'. Wrap it to either proc or lambda."
-    end
-  end
-end

data/lib/dry/initializer/exceptions/params_order_error.rb

@@ -1,8 +0,0 @@
-module Dry::Initializer
-  class ParamsOrderError < RuntimeError
-    def initialize(required, optional)
-      super "Optional param '#{optional}'" \
-            " should not preceed required '#{required}'"
-    end
-  end
-end

data/lib/dry/initializer/exceptions/type_constraint_error.rb

@@ -1,7 +0,0 @@
-module Dry::Initializer
-  class TypeConstraintError < TypeError
-    def initialize(name, type)
-      super "#{type} constraint for argument '#{name}' doesn't respond to #call"
-    end
-  end
-end

data/lib/dry/initializer/instance_dsl.rb

@@ -1,15 +0,0 @@
-module Dry::Initializer
-  module InstanceDSL
-    private
-
-    # The method is reloaded explicitly
-    # in a class that extend [Dry::Initializer], or in its subclasses.
-    def initialize(*args)
-      __initialize__(*args)
-    end
-
-    # The method is redefined implicitly every time
-    # a `param` or `option` is invoked.
-    def __initialize__(*); end
-  end
-end

data/lib/dry/initializer/option.rb

@@ -1,61 +0,0 @@
-module Dry::Initializer
-  class Option < Attribute
-    # part of __initializer__ definition
-    def initializer_signature
-      "**__options__"
-    end
-
-    # parts of __initalizer__
-    def presetter
-      "@#{target} = #{undefined}" if dispensable? && @undefined
-    end
-
-    def safe_setter
-      "@#{target} = #{safe_coerced}#{maybe_optional}"
-    end
-
-    def fast_setter
-      return safe_setter unless dispensable?
-      "@#{target} = __options__.key?(:'#{source}')" \
-                  " ? #{safe_coerced}" \
-                  " : #{undefined}"
-    end
-
-    # part of __defaults__
-    def default_hash
-      super :option
-    end
-
-    # part of __coercers__
-    def coercer_hash
-      super :option
-    end
-
-    private
-
-    def dispensable?
-      optional && !default
-    end
-
-    def maybe_optional
-      " if __options__.key? :'#{source}'" if dispensable?
-    end
-
-    def safe_coerced
-      return safe_default unless coercer
-      "__coercers__[:'option_#{source}'].call(#{safe_default})"
-    end
-
-    def safe_default
-      "__options__.fetch(:'#{source}')#{default_part}"
-    end
-
-    def default_part
-      if default
-        " { instance_exec(&__defaults__[:'option_#{source}']) }"
-      elsif !optional
-        " { raise ArgumentError, \"option :'#{source}' is required\" }"
-      end
-    end
-  end
-end

data/lib/dry/initializer/param.rb

@@ -1,52 +0,0 @@
-module Dry::Initializer
-  class Param < Attribute
-    # part of __initializer__ definition
-    def initializer_signature
-      optional ? "#{target} = #{undefined}" : target
-    end
-
-    # parts of __initalizer__
-    def presetter; end
-
-    def safe_setter
-      "@#{target} = #{maybe_coerced}"
-    end
-
-    def fast_setter
-      safe_setter
-    end
-
-    # part of __defaults__
-    def default_hash
-      super :param
-    end
-
-    # part of __coercers__
-    def coercer_hash
-      super :param
-    end
-
-    private
-
-    def initialize(*args, **options)
-      fail ArgumentError.new("Do not rename params") if options.key? :as
-      super
-    end
-
-    def maybe_coerced
-      return maybe_default unless coercer
-      "__coercers__[:param_#{target}].call(#{maybe_default})"
-    end
-
-    def maybe_default
-      "#{target}#{default_part}"
-    end
-
-    def default_part
-      return unless default
-      " == #{undefined} ?" \
-      " instance_exec(&__defaults__[:param_#{target}]) :" \
-      " #{target}"
-    end
-  end
-end

data/spec/gem_enhancement_spec.rb

@@ -1,18 +0,0 @@
-describe "gem enhancement" do
-  before do
-    Dry::Initializer::Attribute.dispatchers << ->(string: false, **op) do
-      op[:type] = proc(&:to_s) if string
-      op
-    end
-
-    class Test::Foo
-      extend Dry::Initializer
-      param :bar, string: true
-    end
-  end
-
-  it "works" do
-    foo = Test::Foo.new(:BAZ)
-    expect(foo.bar).to eq "BAZ"
-  end
-end