dry-core 0.4.9 → 0.7.1

data/lib/dry-core.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-require 'dry/core'
+require "dry/core"

data/lib/dry/core.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'dry/core/version'
+require "dry/core/version"
 
 # :nodoc:
 module Dry

data/lib/dry/core/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/map'
+require "concurrent/map"
 
 module Dry
   module Core
@@ -46,7 +46,8 @@ module Dry
       #       this means you shouldn't pass Procs in args unless you're sure
       #       they are always the same instances, otherwise you introduce a memory leak
       #
-      # @return [Object] block's return value (cached for subsequent calls with the same argument values)
+      # @return [Object] block's return value (cached for subsequent calls with
+      #   the same argument values)
       def fetch_or_store(*args, &block)
         cache.fetch_or_store(args.hash, &block)
       end

data/lib/dry/core/class_attributes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'dry/core/constants'
-require 'dry/core/errors'
+require "dry/core/constants"
+require "dry/core/errors"
 
 module Dry
   module Core
@@ -51,22 +51,42 @@ module Dry
       #    defines :one, :two, type: Dry::Types['strict.int']
       #  end
       #
-      def defines(*args, type: Object)
-        mod = Module.new do
+      # @example with coercion using Proc
+      #
+      #  class Bar
+      #    extend Dry::Core::ClassAttributes
+      #
+      #    defines :one, coerce: proc { |value| value.to_s }
+      #  end
+      #
+      # @example with coercion using dry-types
+      #
+      #  class Bar
+      #    extend Dry::Core::ClassAttributes
+      #
+      #    defines :one, coerce: Dry::Types['coercible.string']
+      #  end
+      #
+      def defines(*args, type: ::Object, coerce: IDENTITY) # rubocop:disable Metrics/PerceivedComplexity
+        unless coerce.respond_to?(:call)
+          raise ::ArgumentError, "Non-callable coerce option: #{coerce.inspect}"
+        end
+
+        mod = ::Module.new do
           args.each do |name|
-            define_method(name) do |value = Undefined|
-              ivar = "@#{name}"
+            ivar = :"@#{name}"
 
-              if value == Undefined
+            define_method(name) do |value = Undefined|
+              if Undefined.equal?(value)
                 if instance_variable_defined?(ivar)
                   instance_variable_get(ivar)
-                else
+                else # rubocop:disable Style/EmptyElse
                   nil
                 end
+              elsif type === value # rubocop:disable Style/CaseEquality
+                instance_variable_set(ivar, coerce.call(value))
               else
-                raise InvalidClassAttributeValue.new(name, value) unless type === value
-
-                instance_variable_set(ivar, value)
+                raise InvalidClassAttributeValue.new(name, value)
               end
             end
           end

data/lib/dry/core/class_builder.rb

@@ -6,9 +6,7 @@ module Dry
     class ClassBuilder
       ParentClassMismatch = Class.new(TypeError)
 
-      attr_reader :name
-      attr_reader :parent
-      attr_reader :namespace
+      attr_reader :name, :parent, :namespace
 
       def initialize(name:, parent: nil, namespace: nil)
         @name = name
@@ -72,8 +70,6 @@ module Dry
           remove_const(name)
           const_set(name, klass)
 
-          const_get(name).name if RUBY_VERSION < '2.4'
-
           remove_const(name)
           const_set(name, base)
         end
@@ -85,14 +81,14 @@ module Dry
       def create_base(namespace, name, parent)
         begin
           namespace.const_get(name)
-        rescue NameError
+        rescue NameError # rubocop:disable Lint/SuppressedException
         end
 
         if namespace.const_defined?(name, false)
           existing = namespace.const_get(name)
 
           unless existing <= parent
-            raise ParentClassMismatch, "#{ existing.name } must be a subclass of #{ parent.name }"
+            raise ParentClassMismatch, "#{existing.name} must be a subclass of #{parent.name}"
           end
 
           existing

data/lib/dry/core/constants.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
 module Dry
   module Core
@@ -23,16 +23,18 @@ module Dry
       # An empty list of options
       EMPTY_OPTS = {}.freeze
       # An empty set
-      EMPTY_SET = Set.new.freeze
+      EMPTY_SET = ::Set.new.freeze
       # An empty string
-      EMPTY_STRING = ''.freeze
+      EMPTY_STRING = ""
+      # Identity function
+      IDENTITY = (-> x { x }).freeze
 
       # A special value you can use as a default to know if no arguments
-      # were passed to you method
+      # were passed to the method
       #
       # @example
       #   def method(value = Undefined)
-      #     if value == Undefined
+      #     if Undefined.equal?(value)
       #       puts 'no args'
       #     else
       #       puts value
@@ -40,16 +42,16 @@ module Dry
       #   end
       Undefined = Object.new.tap do |undefined|
         # @api private
-        Self = -> { Undefined }
+        Self = -> { Undefined } # rubocop:disable Lint/ConstantDefinitionInBlock
 
         # @api public
         def undefined.to_s
-          'Undefined'
+          "Undefined"
         end
 
         # @api public
         def undefined.inspect
-          'Undefined'
+          "Undefined"
         end
 
         # Pick a value, if the first argument is not Undefined, return it back,
@@ -60,7 +62,7 @@ module Dry
         #     1 + Undefined.default(val, 2)
         #   end
         #
-        def undefined.default(x, y = self)
+        def undefined.default(x, y = self) # rubocop:disable Naming/MethodParameterName
           if equal?(x)
             if equal?(y)
               yield

data/lib/dry/core/deprecations.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'logger'
+require "logger"
 
 module Dry
   module Core
@@ -17,7 +17,7 @@ module Dry
     #     def old_api; end
     #     def new_api; end
     #
-    #     deprecate_method :old_api, :new_api, "old_api is no-no"
+    #     deprecate :old_api, :new_api, message: "old_api is no-no"
     #   end
     #
     # @example You also can use this module for your custom messages
@@ -33,24 +33,34 @@ module Dry
         # Prints a warning
         #
         # @param [String] msg Warning string
-        def warn(msg, tag: nil)
-          tagged = "[#{tag || 'deprecated'}] #{msg.gsub(/^\s+/, '')}"
-          logger.warn(tagged)
+        # @param [String] tag Tag to help identify the source of the warning.
+        #   Defaults to "deprecated"
+        # @param [Integer] Caller frame to add to the message
+        def warn(msg, tag: nil, uplevel: nil)
+          caller_info = uplevel.nil? ? nil : "#{caller_locations(uplevel + 2, 1)[0]} "
+          tag = "[#{tag || "deprecated"}] "
+          hint = msg.gsub(/^\s+/, "")
+
+          logger.warn("#{caller_info}#{tag}#{hint}")
         end
 
         # Wraps arguments with a standard message format and prints a warning
         #
         # @param [Object] name what is deprecated
         # @param [String] msg additional message usually containing upgrade instructions
-        def announce(name, msg, tag: nil)
-          warn(deprecation_message(name, msg), tag: tag)
+        def announce(name, msg, tag: nil, uplevel: nil)
+          # Bump the uplevel (if provided) by one to account for the uplevel calculation
+          # taking place one frame deeper in `.warn`
+          uplevel += 1 if uplevel
+
+          warn(deprecation_message(name, msg), tag: tag, uplevel: uplevel)
         end
 
         # @api private
         def deprecation_message(name, msg)
           <<-MSG
-            #{ name } is deprecated and will be removed in the next major version
-            #{ msg }
+            #{name} is deprecated and will be removed in the next major version
+            #{msg}
           MSG
         end
 
@@ -92,12 +102,12 @@ module Dry
         #   @param [#warn] logger
         #
         # @api public
-        def set_logger!(output = $stderr)
+        def set_logger!(output = $stderr) # rubocop:disable Naming/AccessorMethodName
           if output.respond_to?(:warn)
             @logger = output
           else
             @logger = Logger.new(output).tap do |logger|
-              logger.formatter = proc { |_, _, _, msg| "#{ msg }\n" }
+              logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
             end
           end
         end
@@ -108,8 +118,9 @@ module Dry
       end
 
       # @api private
-      class Tagged < Module
+      class Tagged < ::Module
         def initialize(tag)
+          super()
           @tag = tag
         end
 
@@ -145,8 +156,8 @@ module Dry
         # @option [String] message optional deprecation message
         def deprecate(old_name, new_name = nil, message: nil)
           full_msg = Deprecations.deprecated_name_message(
-            "#{self.name}##{old_name}",
-            new_name ? "#{self.name}##{new_name}" : nil,
+            "#{name}##{old_name}",
+            new_name ? "#{name}##{new_name}" : nil,
             message
           )
           mod = self
@@ -155,7 +166,7 @@ module Dry
             undef_method old_name if method_defined?(old_name)
 
             define_method(old_name) do |*args, &block|
-              mod.warn("#{ full_msg }\n#{ STACK.() }")
+              mod.warn("#{full_msg}\n#{STACK.()}")
               __send__(new_name, *args, &block)
             end
           else
@@ -165,7 +176,7 @@ module Dry
             undef_method old_name
 
             define_method(old_name) do |*args, &block|
-              mod.warn("#{ full_msg }\n#{ STACK.() }")
+              mod.warn("#{full_msg}\n#{STACK.()}")
               __send__(aliased_name, *args, &block)
             end
           end
@@ -178,8 +189,8 @@ module Dry
         # @option [String] message optional deprecation message
         def deprecate_class_method(old_name, new_name = nil, message: nil)
           full_msg = Deprecations.deprecated_name_message(
-            "#{self.name}.#{old_name}",
-            new_name ? "#{self.name}.#{new_name}" : nil,
+            "#{name}.#{old_name}",
+            new_name ? "#{name}.#{new_name}" : nil,
             message
           )
 
@@ -189,7 +200,7 @@ module Dry
             undef_method old_name if method_defined?(old_name)
 
             define_method(old_name) do |*args, &block|
-              warn("#{ full_msg }\n#{ STACK.() }")
+              warn("#{full_msg}\n#{STACK.()}")
               meth.call(*args, &block)
             end
           end
@@ -203,14 +214,14 @@ module Dry
           remove_const(constant_name)
 
           full_msg = Deprecations.deprecated_name_message(
-            "#{self.name}::#{constant_name}",
+            "#{name}::#{constant_name}",
             message
           )
 
           mod = Module.new do
             define_method(:const_missing) do |missing|
               if missing == constant_name
-                warn("#{ full_msg }\n#{ STACK.() }")
+                warn("#{full_msg}\n#{STACK.()}")
                 value
               else
                 super(missing)

data/lib/dry/core/descendants_tracker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'concurrent/array'
+require "concurrent/array"
 
 module Dry
   module Core

data/lib/dry/core/equalizer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Dry
+  # Build an equalizer module for the inclusion in other class
+  #
+  # ## Credits
+  #
+  # Equalizer has been originally imported from the equalizer gem created by Dan Kubb
+  #
+  # @api public
+  def self.Equalizer(*keys, **options)
+    Dry::Core::Equalizer.new(*keys, **options)
+  end
+
+  module Core
+    # Define equality, equivalence and inspection methods
+    class Equalizer < ::Module
+      # Initialize an Equalizer with the given keys
+      #
+      # Will use the keys with which it is initialized to define #cmp?,
+      # #hash, and #inspect
+      #
+      # @param [Array<Symbol>] keys
+      # @param [Hash] options
+      # @option options [Boolean] :inspect whether to define #inspect method
+      # @option options [Boolean] :immutable whether to memoize #hash method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def initialize(*keys, **options)
+        super()
+        @keys = keys.uniq
+        define_methods(**options)
+        freeze
+      end
+
+      private
+
+      # Hook called when module is included
+      #
+      # @param [Module] descendant
+      #   the module or class including Equalizer
+      #
+      # @return [self]
+      #
+      # @api private
+      def included(descendant)
+        super
+        descendant.include Methods
+      end
+
+      # Define the equalizer methods based on #keys
+      #
+      # @param [Boolean] inspect whether to define #inspect method
+      # @param [Boolean] immutable whether to memoize #hash method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_methods(inspect: true, immutable: false)
+        define_cmp_method
+        define_hash_method(immutable: immutable)
+        define_inspect_method if inspect
+      end
+
+      # Define an #cmp? method based on the instance's values identified by #keys
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_cmp_method
+        keys = @keys
+        define_method(:cmp?) do |comparator, other|
+          keys.all? do |key|
+            __send__(key).public_send(comparator, other.__send__(key))
+          end
+        end
+        private :cmp?
+      end
+
+      # Define a #hash method based on the instance's values identified by #keys
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_hash_method(immutable:)
+        calculate_hash = ->(obj) { @keys.map { |key| obj.__send__(key) }.push(obj.class).hash }
+        if immutable
+          define_method(:hash) do
+            @__hash__ ||= calculate_hash.call(self)
+          end
+          define_method(:freeze) do
+            hash
+            super()
+          end
+        else
+          define_method(:hash) do
+            calculate_hash.call(self)
+          end
+        end
+      end
+
+      # Define an inspect method that reports the values of the instance's keys
+      #
+      # @return [undefined]
+      #
+      # @api private
+      def define_inspect_method
+        keys = @keys
+        define_method(:inspect) do
+          klass = self.class
+          name  = klass.name || klass.inspect
+          "#<#{name}#{keys.map { |key| " #{key}=#{__send__(key).inspect}" }.join}>"
+        end
+      end
+
+      # The comparison methods
+      module Methods
+        # Compare the object with other object for equality
+        #
+        # @example
+        #   object.eql?(other)  # => true or false
+        #
+        # @param [Object] other
+        #   the other object to compare with
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def eql?(other)
+          instance_of?(other.class) && cmp?(__method__, other)
+        end
+
+        # Compare the object with other object for equivalency
+        #
+        # @example
+        #   object == other  # => true or false
+        #
+        # @param [Object] other
+        #   the other object to compare with
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def ==(other)
+          other.is_a?(self.class) && cmp?(__method__, other)
+        end
+      end
+    end
+  end
+end