dry-core 0.4.7 → 0.6.0

data/lib/dry-core.rb

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

data/lib/dry/core.rb

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

data/lib/dry/core/cache.rb

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

data/lib/dry/core/class_attributes.rb

@@ -1,5 +1,7 @@
-require 'dry/core/constants'
-require 'dry/core/errors'
+# frozen_string_literal: true
+
+require "dry/core/constants"
+require "dry/core/errors"
 
 module Dry
   module Core
@@ -49,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)
+        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
                   nil
                 end
+              elsif type === value
+                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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dry
   module Core
     # Class for generating more classes
@@ -70,8 +72,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
@@ -90,7 +90,7 @@ module Dry
           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,4 +1,6 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
 
 module Dry
   module Core
@@ -6,6 +8,7 @@ module Dry
     #
     # @example Just include this module to your class or module
     #   class Foo
+    #     include Dry::Core::Constants
     #     def call(value = EMPTY_ARRAY)
     #        value.map(&:to_s)
     #     end
@@ -20,41 +23,48 @@ 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 = "".freeze
+      # 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
       #     end
       #   end
       Undefined = Object.new.tap do |undefined|
+        # @api private
+        Self = -> { Undefined }
+
+        # @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,
         # otherwise return the second arg or yield the block.
         #
         # @example
-        #  def method(val = Undefined)
-        #    1 + Undefined.default(val, 2)
-        #  end
+        #   def method(val = Undefined)
+        #     1 + Undefined.default(val, 2)
+        #   end
         #
         def undefined.default(x, y = self)
-          if x.equal?(self)
-            if y.equal?(self)
+          if equal?(x)
+            if equal?(y)
               yield
             else
               y
@@ -63,6 +73,36 @@ module Dry
             x
           end
         end
+
+        # Map a non-undefined value
+        #
+        # @example
+        #   def add_five(val = Undefined)
+        #     Undefined.map(val) { |x| x + 5 }
+        #   end
+        #
+        def undefined.map(value)
+          if equal?(value)
+            self
+          else
+            yield(value)
+          end
+        end
+
+        # @api public
+        def undefined.dup
+          self
+        end
+
+        # @api public
+        def undefined.clone
+          self
+        end
+
+        # @api public
+        def undefined.coalesce(*args)
+          args.find(Self) { |x| !equal?(x) }
+        end
       end.freeze
 
       def self.included(base)

data/lib/dry/core/deprecations.rb

@@ -1,4 +1,6 @@
-require 'logger'
+# frozen_string_literal: true
+
+require "logger"
 
 module Dry
   module Core
@@ -15,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
@@ -31,24 +33,31 @@ 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[uplevel]
+          tag = "[#{tag || "deprecated"}]"
+          hint = msg.gsub(/^\s+/, "")
+          logger.warn(
+            [caller_info, tag, hint].compact.join(" ")
+          )
         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)
+          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
 
@@ -95,7 +104,7 @@ module Dry
             @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
@@ -153,7 +162,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
@@ -163,7 +172,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
@@ -187,7 +196,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
@@ -208,7 +217,7 @@ module Dry
           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,4 +1,6 @@
-require 'concurrent/array'
+# frozen_string_literal: true
+
+require "concurrent/array"
 
 module Dry
   module Core

data/lib/dry/core/equalizer.rb

@@ -0,0 +1,151 @@
+# 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)
+        @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