dry-types 1.5.1 → 1.7.2

data/lib/dry/types/decorator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/types/options"
-
 module Dry
   module Types
     # Common API for types

data/lib/dry/types/default.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require "dry/types/decorator"
-
 module Dry
   module Types
     # Default types are useful when a missing value should be replaced by a default one
@@ -53,7 +50,7 @@ module Dry
       # @param [Object] value
       #
       # @api private
-      def initialize(type, value, **options)
+      def initialize(type, value, **)
         super
         @value = value
       end
@@ -65,8 +62,8 @@ module Dry
       # @return [Default]
       #
       # @api public
-      def constrained(*args)
-        type.constrained(*args).default(value)
+      def constrained(...)
+        type.constrained(...).default(value)
       end
 
       # @return [true]

data/lib/dry/types/enum.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require "dry/types/decorator"
-
 module Dry
   module Types
     # Enum types can be used to define an enum on top of an existing type

data/lib/dry/types/errors.rb

@@ -51,6 +51,7 @@ module Dry
 
       # @param [Array<CoercionError>] errors
       def initialize(errors)
+        super("")
         @errors = errors
       end
 
@@ -66,11 +67,22 @@ module Dry
     end
 
     class SchemaError < CoercionError
+      # @return [String, Symbol]
+      attr_reader :key
+
+      # @return [Object]
+      attr_reader :value
+
       # @param [String,Symbol] key
       # @param [Object] value
       # @param [String, #to_s] result
       def initialize(key, value, result)
-        super("#{value.inspect} (#{value.class}) has invalid type for :#{key} violates constraints (#{result} failed)")
+        @key = key
+        @value = value
+        super(
+          "#{value.inspect} (#{value.class}) has invalid type "\
+          "for :#{key} violates constraints (#{result} failed)"
+        )
       end
     end
 

data/lib/dry/types/extensions/maybe.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require "dry/monads/maybe"
-require "dry/types/decorator"
+require "dry/monads"
+require "dry/monads/version"
+
+if Gem::Version.new(Dry::Monads::VERSION) < Gem::Version.new("1.5.0")
+  raise "dry-types requires dry-monads >= 1.5.0"
+end
 
 module Dry
   module Types
@@ -15,7 +18,7 @@ module Dry
       include Decorator
       include Builder
       include Printable
-      include ::Dry::Monads::Maybe::Mixin
+      include ::Dry::Monads[:maybe]
 
       # @param [Dry::Monads::Maybe, Object] input
       #
@@ -99,7 +102,7 @@ module Dry
     end
 
     # @api private
-    class Schema::Key
+    class Schema::Key # rubocop:disable Style/ClassAndModuleChildren
       # @api private
       def maybe
         __new__(type.maybe)

data/lib/dry/types/extensions/monads.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
-require "dry/monads/result"
+require "dry/monads"
+require "dry/monads/version"
+
+if Gem::Version.new(Dry::Monads::VERSION) < Gem::Version.new("1.5.0")
+  raise "dry-types requires dry-monads >= 1.5.0"
+end
 
 module Dry
   module Types
@@ -8,7 +13,7 @@ module Dry
     #
     # @api public
     class Result
-      include Dry::Monads::Result::Mixin
+      include ::Dry::Monads[:result]
 
       # Turn result into a monad
       #

data/lib/dry/types/fn_container.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/types/container"
-
 module Dry
   module Types
     # Internal container for constructor functions used by the built-in types

data/lib/dry/types/hash/constructor.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/types/constructor"
-
 module Dry
   module Types
     # Hash type exposes additional APIs for working with schema hashes
@@ -24,8 +22,8 @@ module Dry
         # @see Dry::Types::Array#of
         #
         # @api public
-        def schema(*args)
-          type.schema(*args).constructor(fn, meta: meta)
+        def schema(...)
+          type.schema(...).constructor(fn, meta: meta)
         end
       end
     end

data/lib/dry/types/hash.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/types/hash/constructor"
-
 module Dry
   module Types
     # Hash types can be used to define maps and schemas
@@ -51,7 +49,7 @@ module Dry
       # @api private
       def weak(*)
         raise "Support for old hash schemas was removed, please refer to the CHANGELOG "\
-              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
+              "on how to proceed with the new API https://github.com/dry-rb/dry-types/blob/main/CHANGELOG.md"
       end
       alias_method :permissive, :weak
       alias_method :strict, :weak
@@ -132,6 +130,3 @@ module Dry
     end
   end
 end
-
-require "dry/types/schema/key"
-require "dry/types/schema"

data/lib/dry/types/implication.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Implication type
+    #
+    # @api public
+    class Implication
+      include Composition
+
+      def self.operator
+        :>
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input)
+        if left.try(input).success?
+          right.call_unsafe(input)
+        else
+          input
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        if left.try(input).success?
+          right.call_safe(input, &block)
+        else
+          input
+        end
+      end
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input)
+        if left.try(input).success?
+          right.try(input)
+        else
+          Result::Success.new(input)
+        end
+      end
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def primitive?(value)
+        if left.primitive?(value)
+          right.primitive?(value)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/intersection.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/options"
+require "dry/types/meta"
+
+module Dry
+  module Types
+    # Intersection type
+    #
+    # @api public
+    class Intersection
+      include Composition
+
+      def self.operator
+        :&
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_unsafe(input)
+        merge_results(left.call_unsafe(input), right.call_unsafe(input))
+      end
+
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        try_sides(input, &block).input
+      end
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input)
+        try_sides(input) do |failure|
+          if block_given?
+            yield(failure)
+          else
+            failure
+          end
+        end
+      end
+
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def primitive?(value)
+        left.primitive?(value) && right.primitive?(value)
+      end
+
+      private
+
+      # @api private
+      def try_sides(input, &block)
+        results = []
+
+        [left, right].each do |side|
+          result = try_side(side, input, &block)
+          return result if result.failure?
+
+          results << result
+        end
+
+        Result::Success.new(merge_results(*results.map(&:input)))
+      end
+
+      # @api private
+      def try_side(side, input)
+        failure = nil
+
+        result = side.try(input) do |f|
+          failure = f
+          yield(f)
+        end
+
+        if result.is_a?(Result)
+          result
+        elsif failure
+          Result::Failure.new(result, failure)
+        else
+          Result::Success.new(result)
+        end
+      end
+
+      # @api private
+      def merge_results(left_result, right_result)
+        case left_result
+        when ::Array
+          left_result
+            .zip(right_result)
+            .map { |lhs, rhs| merge_results(lhs, rhs) }
+        when ::Hash
+          left_result.merge(right_result)
+        else
+          left_result
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/lax.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/deprecations"
-require "dry/types/decorator"
-
 module Dry
   module Types
     # Lax types rescue from type-related errors when constructors fail
@@ -68,7 +65,7 @@ module Dry
       end
     end
 
-    extend ::Dry::Core::Deprecations[:'dry-types']
+    extend ::Dry::Core::Deprecations[:"dry-types"]
     Safe = Lax
     deprecate_constant(:Safe)
   end

data/lib/dry/types/map.rb

@@ -14,15 +14,17 @@ module Dry
     #   # => {1 => 'right'}
     #
     #   type.('1' => 'wrong')
-    #   # Dry::Types::MapError: "1" violates constraints (type?(Integer, "1") AND gteq?(1, "1") AND lteq?(10, "1") failed)
+    #   # Dry::Types::MapError: "1" violates constraints (type?(Integer, "1")
+    #   #                                                 AND gteq?(1, "1")
+    #   #                                                 AND lteq?(10, "1") failed)
     #
     #   type.(11 => 'wrong')
     #   # Dry::Types::MapError: 11 violates constraints (lteq?(10, 11) failed)
     #
     # @api public
     class Map < Nominal
-      def initialize(_primitive, key_type: Types["any"], value_type: Types["any"], meta: EMPTY_HASH)
-        super(_primitive, key_type: key_type, value_type: value_type, meta: meta)
+      def initialize(primitive, key_type: Types["any"], value_type: Types["any"], meta: EMPTY_HASH)
+        super(primitive, key_type: key_type, value_type: value_type, meta: meta)
       end
 
       # @return [Type]
@@ -100,6 +102,8 @@ module Dry
       private
 
       # @api private
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize
       def coerce(input)
         unless primitive?(input)
           return failure(
@@ -131,6 +135,8 @@ module Dry
           failure(input, MultipleError.new(failures))
         end
       end
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize
     end
   end
 end

data/lib/dry/types/module.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/deprecations"
 require "dry/types/builder_methods"
 
 module Dry
@@ -8,7 +7,7 @@ module Dry
     # Export types registered in a container as module constants.
     # @example
     #   module Types
-    #     include Dry::Types(:strict, :coercible, :nominal, default: :strict)
+    #     include Dry.Types(:strict, :coercible, :nominal, default: :strict)
     #   end
     #
     #   Types.constants
@@ -26,10 +25,10 @@ module Dry
         extend(BuilderMethods)
 
         if constants.key?(:Nominal)
-          singleton_class.send(:define_method, :included) do |base|
+          singleton_class.define_method(:included) do |base|
             super(base)
             base.instance_exec(const_get(:Nominal, false)) do |nominal|
-              extend Dry::Core::Deprecations[:'dry-types']
+              extend Dry::Core::Deprecations[:"dry-types"]
               const_set(:Definition, nominal)
               deprecate_constant(:Definition, message: "Nominal")
             end
@@ -38,13 +37,16 @@ module Dry
       end
 
       # @api private
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def type_constants(*namespaces, default: Undefined, **aliases)
         if namespaces.empty? && aliases.empty? && Undefined.equal?(default)
           default_ns = :Strict
         elsif Undefined.equal?(default)
           default_ns = Undefined
         else
-          default_ns = Inflector.camelize(default).to_sym
+          default_ns = Types::Inflector.camelize(default).to_sym
         end
 
         tree = registry_tree
@@ -52,7 +54,9 @@ module Dry
         if namespaces.empty? && aliases.empty?
           modules = tree.select { |_, v| v.is_a?(::Hash) }.map(&:first)
         else
-          modules = (namespaces + aliases.keys).map { |n| Inflector.camelize(n).to_sym }
+          modules = (namespaces + aliases.keys).map { |n|
+            Types::Inflector.camelize(n).to_sym
+          }
         end
 
         tree.each_with_object({}) do |(key, value), constants|
@@ -64,13 +68,16 @@ module Dry
           constants.update(value) if key == default_ns
         end
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
 
       # @api private
       def registry_tree
         @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
           type = @registry[key]
           *modules, const_name = key.split(".").map { |part|
-            Inflector.camelize(part).to_sym
+            Types::Inflector.camelize(part).to_sym
           }
           next if modules.empty?
 
@@ -91,9 +98,11 @@ module Dry
           ns.to_sym unless path.empty?
         }.compact.uniq
 
-        (referenced.uniq - known).each do |name|
+        unknown = (referenced.uniq - known).first
+
+        if unknown
           raise ArgumentError,
-                "#{name.inspect} is not a known type namespace. "\
+                "#{unknown.inspect} is not a known type namespace. "\
                 "Supported options are #{known.map(&:inspect).join(", ")}"
         end
       end

data/lib/dry/types/nominal.rb

@@ -1,12 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/deprecations"
-require "dry/core/equalizer"
-require "dry/types/builder"
-require "dry/types/result"
-require "dry/types/options"
-require "dry/types/meta"
-
 module Dry
   module Types
     # Nominal types define a primitive class and do not apply any constructors or constraints
@@ -20,7 +13,7 @@ module Dry
       include Meta
       include Builder
       include Printable
-      include Dry::Equalizer(:primitive, :options, :meta, inspect: false, immutable: true)
+      include ::Dry::Equalizer(:primitive, :options, :meta, inspect: false, immutable: true)
 
       # @return [Class]
       attr_reader :primitive
@@ -199,12 +192,8 @@ module Dry
       end
     end
 
-    extend Dry::Core::Deprecations[:'dry-types']
+    extend ::Dry::Core::Deprecations[:"dry-types"]
     Definition = Nominal
     deprecate_constant(:Definition, message: "Nominal")
   end
 end
-
-require "dry/types/array"
-require "dry/types/hash"
-require "dry/types/map"

data/lib/dry/types/predicate_inferrer.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/cache"
-require "dry/core/class_attributes"
-require "dry/types/predicate_registry"
-
 module Dry
   module Types
     # PredicateInferrer returns the list of predicates used by a type.
@@ -55,7 +51,7 @@ module Dry
         end
 
         # @api private
-        def infer_predicate(type)
+        def infer_predicate(type) # rubocop:disable Metrics/PerceivedComplexity
           pred = TYPE_TO_PREDICATE.fetch(type) do
             if type.name.nil? || self.class.infer_predicate_by_class_name.equal?(false)
               nil
@@ -175,9 +171,9 @@ module Dry
         def visit_predicate(node)
           pred, args = node
 
-          if pred.equal?(:type?)
+          if pred.equal?(:type?) || !registry.key?(pred)
             EMPTY_ARRAY
-          elsif registry.key?(pred)
+          else
             *curried, _ = args
             values = curried.map { |_, v| v }
 
@@ -186,11 +182,14 @@ module Dry
             else
               [pred => values[0]]
             end
-          else
-            EMPTY_ARRAY
           end
         end
 
+        # @api private
+        def visit_map(_node)
+          raise NotImplementedError, "map types are not supported yet"
+        end
+
         private
 
         # @api private

data/lib/dry/types/predicate_registry.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/logic/predicates"
-
 module Dry
   module Types
     # A registry with predicate objects from `Dry::Logic::Predicates`
@@ -14,20 +12,22 @@ module Dry
       # @api private
       attr_reader :has_predicate
 
+      KERNEL_RESPOND_TO = ::Kernel.instance_method(:respond_to?)
+      private_constant(:KERNEL_RESPOND_TO)
+
       # @api private
       def initialize(predicates = Logic::Predicates)
         @predicates = predicates
-        @has_predicate = ::Kernel.instance_method(:respond_to?).bind(@predicates)
       end
 
       # @api private
-      def [](name)
-        predicates[name]
+      def key?(name)
+        KERNEL_RESPOND_TO.bind_call(@predicates, name)
       end
 
       # @api private
-      def key?(name)
-        has_predicate.(name)
+      def [](name)
+        predicates[name]
       end
     end
   end

data/lib/dry/types/primitive_inferrer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/cache"
-
 module Dry
   module Types
     # PrimitiveInferrer returns the list of classes matching a type.

data/lib/dry/types/printer/composition.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Printer
+      # @api private
+      class Composition
+        def initialize(printer, composition_class)
+          @printer = printer
+          @composition_class = composition_class
+          freeze
+        end
+
+        def visit(composition)
+          visit_constructors(composition) do |constructors|
+            @printer.visit_options(composition.options, composition.meta) do |opts|
+              yield "#{@composition_class.composition_name}<#{constructors}#{opts}>"
+            end
+          end
+        end
+
+        private
+
+        def visit_constructors(composition)
+          visit_constructor(composition.left) do |left|
+            visit_constructor(composition.right) do |right|
+              yield "#{left} #{@composition_class.operator} #{right}"
+            end
+          end
+        end
+
+        def visit_constructor(type, &block)
+          case type
+          when @composition_class
+            visit_constructors(type, &block)
+          else
+            @printer.visit(type, &block)
+          end
+        end
+      end
+    end
+  end
+end