dry-types 1.5.1 → 1.7.2

data/lib/dry/types/printer.rb

@@ -1,15 +1,21 @@
 # frozen_string_literal: true
 
+require "dry/types/printer/composition"
+
 module Dry
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/PerceivedComplexity
   module Types
     # @api private
     class Printer
       MAPPING = {
         Nominal => :visit_nominal,
         Constructor => :visit_constructor,
-        Constrained => :visit_constrained,
-        Constrained::Coercible => :visit_constrained,
-        Hash => :visit_hash,
+        [
+          Constrained,
+          Constrained::Coercible
+        ] => :visit_constrained,
+        Types::Hash => :visit_hash,
         Schema => :visit_schema,
         Schema::Key => :visit_key,
         Map => :visit_map,
@@ -17,12 +23,22 @@ module Dry
         Array::Member => :visit_array_member,
         Lax => :visit_lax,
         Enum => :visit_enum,
-        Default => :visit_default,
-        Default::Callable => :visit_default,
-        Sum => :visit_sum,
-        Sum::Constrained => :visit_sum,
+        [Default, Default::Callable] => :visit_default,
+        [
+          Sum,
+          Sum::Constrained,
+          Intersection,
+          Intersection::Constrained,
+          Implication,
+          Implication::Constrained
+        ] => :visit_composition,
         Any.class => :visit_any
-      }
+      }.flat_map { |k, v| Array(k).map { |kk| [kk, v] } }.to_h
+
+      def initialize
+        @composition_printers = {}
+        freeze
+      end
 
       def call(type)
         output = "".dup
@@ -85,106 +101,10 @@ module Dry
         end
       end
 
-      def visit_schema(schema)
-        options = schema.options.dup
-        size = schema.count
-        key_fn_str = ""
-        type_fn_str = ""
-        strict_str = ""
-
-        strict_str = "strict " if options.delete(:strict)
-
-        if key_fn = options.delete(:key_transform_fn)
-          visit_callable(key_fn) do |fn|
-            key_fn_str = "key_fn=#{fn} "
-          end
-        end
-
-        if type_fn = options.delete(:type_transform_fn)
-          visit_callable(type_fn) do |fn|
-            type_fn_str = "type_fn=#{fn} "
-          end
-        end
-
-        keys = options.delete(:keys)
-
-        visit_options(options, schema.meta) do |opts|
-          opts = "#{opts[1..-1]} " unless opts.empty?
-          schema_parameters = "#{key_fn_str}#{type_fn_str}#{strict_str}#{opts}"
-
-          header = "Schema<#{schema_parameters}keys={"
-
-          if size.zero?
-            yield "#{header}}>"
-          else
-            yield header.dup << keys.map { |key|
-              visit(key) { |type| type }
-            }.join(" ") << "}>"
-          end
-        end
-      end
-
-      def visit_map(map)
-        visit(map.key_type) do |key|
-          visit(map.value_type) do |value|
-            options = map.options.dup
-            options.delete(:key_type)
-            options.delete(:value_type)
-
-            visit_options(options) do |_opts|
-              yield "Map<#{key} => #{value}>"
-            end
-          end
-        end
-      end
-
-      def visit_key(key)
-        visit(key.type) do |type|
-          if key.required?
-            yield "#{key.name}: #{type}"
-          else
-            yield "#{key.name}?: #{type}"
-          end
-        end
-      end
-
-      def visit_sum(sum)
-        visit_sum_constructors(sum) do |constructors|
-          visit_options(sum.options, sum.meta) do |opts|
-            yield "Sum<#{constructors}#{opts}>"
-          end
-        end
-      end
-
-      def visit_sum_constructors(sum)
-        case sum.left
-        when Sum
-          visit_sum_constructors(sum.left) do |left|
-            case sum.right
-            when Sum
-              visit_sum_constructors(sum.right) do |right|
-                yield "#{left} | #{right}"
-              end
-            else
-              visit(sum.right) do |right|
-                yield "#{left} | #{right}"
-              end
-            end
-          end
-        else
-          visit(sum.left) do |left|
-            case sum.right
-            when Sum
-              visit_sum_constructors(sum.right) do |right|
-                yield "#{left} | #{right}"
-              end
-            else
-              visit(sum.right) do |right|
-                yield "#{left} | #{right}"
-              end
-            end
-          end
-        end
+      def visit_composition(composition, &block)
+        klass = composition.class
+        @composition_printers[klass] = Composition.new(self, klass)
+        @composition_printers[klass].visit(composition, &block)
       end
 
       def visit_enum(enum)
@@ -232,25 +152,6 @@ module Dry
         end
       end
 
-      def visit_hash(hash)
-        options = hash.options.dup
-        type_fn_str = ""
-
-        if type_fn = options.delete(:type_transform_fn)
-          visit_callable(type_fn) do |fn|
-            type_fn_str = "type_fn=#{fn}"
-          end
-        end
-
-        visit_options(options, hash.meta) do |opts|
-          if opts.empty? && type_fn_str.empty?
-            yield "Hash"
-          else
-            yield "Hash<#{type_fn_str}#{opts}>"
-          end
-        end
-      end
-
       def visit_callable(callable)
         fn = callable.is_a?(String) ? FnContainer[callable] : callable
 
@@ -263,9 +164,9 @@ module Dry
           if line&.zero?
             yield ".#{path}"
           elsif path
-            yield "#{path.sub(Dir.pwd + "/", EMPTY_STRING)}:#{line}"
+            yield "#{path.sub("#{Dir.pwd}/", EMPTY_STRING)}:#{line}"
           else
-            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/) # rubocop:disable Lint/MixedRegexpCaptureTypes
 
             if match
               yield ".#{match[:name]}"
@@ -286,7 +187,89 @@ module Dry
         end
       end
 
-      def visit_options(options, meta = EMPTY_HASH)
+      def visit_schema(schema)
+        options = schema.options.dup
+        size = schema.count
+        key_fn_str = ""
+        type_fn_str = ""
+        strict_str = ""
+
+        strict_str = "strict " if options.delete(:strict)
+
+        if (key_fn = options.delete(:key_transform_fn))
+          visit_callable(key_fn) do |fn|
+            key_fn_str = "key_fn=#{fn} "
+          end
+        end
+
+        if (type_fn = options.delete(:type_transform_fn))
+          visit_callable(type_fn) do |fn|
+            type_fn_str = "type_fn=#{fn} "
+          end
+        end
+
+        keys = options.delete(:keys)
+
+        visit_options(options, schema.meta) do |opts|
+          opts = "#{opts[1..]} " unless opts.empty?
+          schema_parameters = "#{key_fn_str}#{type_fn_str}#{strict_str}#{opts}"
+
+          header = "Schema<#{schema_parameters}keys={"
+
+          if size.zero?
+            yield "#{header}}>"
+          else
+            yield header.dup << keys.map { |key|
+              visit(key) { |type| type }
+            }.join(" ") << "}>"
+          end
+        end
+      end
+
+      def visit_map(map)
+        visit(map.key_type) do |key|
+          visit(map.value_type) do |value|
+            options = map.options.dup
+            options.delete(:key_type)
+            options.delete(:value_type)
+
+            visit_options(options) do |_opts|
+              yield "Map<#{key} => #{value}>"
+            end
+          end
+        end
+      end
+
+      def visit_key(key)
+        visit(key.type) do |type|
+          if key.required?
+            yield "#{key.name}: #{type}"
+          else
+            yield "#{key.name}?: #{type}"
+          end
+        end
+      end
+
+      def visit_hash(hash)
+        options = hash.options.dup
+        type_fn_str = ""
+
+        if (type_fn = options.delete(:type_transform_fn))
+          visit_callable(type_fn) do |fn|
+            type_fn_str = "type_fn=#{fn}"
+          end
+        end
+
+        visit_options(options, hash.meta) do |opts|
+          if opts.empty? && type_fn_str.empty?
+            yield "Hash"
+          else
+            yield "Hash<#{type_fn_str}#{opts}>"
+          end
+        end
+      end
+
+      def visit_options(options, meta = EMPTY_HASH) # rubocop:disable Metrics/PerceivedComplexity
         if options.empty? && meta.empty?
           yield ""
         else
@@ -310,6 +293,8 @@ module Dry
       end
     end
 
-    PRINTER = Printer.new.freeze
+    PRINTER = Printer.new
   end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/PerceivedComplexity
 end

data/lib/dry/types/result.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-
 module Dry
   module Types
     # Result class used by {Type#try}

data/lib/dry/types/schema/key.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require "dry/core/deprecations"
-
 module Dry
   module Types
     # Schema is a hash with explicit member types defined
@@ -15,7 +12,7 @@ module Dry
       #
       # @see Dry::Types::Schema
       class Key
-        extend ::Dry::Core::Deprecations[:'dry-types']
+        extend ::Dry::Core::Deprecations[:"dry-types"]
         include Type
         include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
         include Decorator

data/lib/dry/types/schema.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "dry/types/fn_container"
-
 module Dry
   module Types
     # The built-in Hash type can be defined in terms of keys and associated types
@@ -92,6 +90,8 @@ module Dry
       # @return [Object] if coercion fails and a block is given
       #
       # @api public
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
       def try(input)
         if primitive?(input)
           success = true
@@ -138,6 +138,8 @@ module Dry
           failure
         end
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/PerceivedComplexity
 
       # @param meta [Boolean] Whether to dump the meta to the AST
       #
@@ -167,7 +169,7 @@ module Dry
       # @return [Schema]
       #
       # @api public
-      def strict(strict = true)
+      def strict(strict = true) # rubocop:disable Style/OptionalBooleanParameter
         with(strict: strict)
       end
 
@@ -368,7 +370,7 @@ module Dry
       # Try to add missing keys to the hash
       #
       # @api private
-      def resolve_missing_keys(hash, options)
+      def resolve_missing_keys(hash, options) # rubocop:disable Metrics/PerceivedComplexity
         skip_missing = options.fetch(:skip_missing, false)
         resolve_defaults = options.fetch(:resolve_defaults, true)
 

data/lib/dry/types/sum.rb

@@ -1,71 +1,15 @@
 # frozen_string_literal: true
 
-require "dry/core/equalizer"
-require "dry/types/options"
-require "dry/types/meta"
-
 module Dry
   module Types
     # Sum type
     #
     # @api public
     class Sum
-      include Type
-      include Builder
-      include Options
-      include Meta
-      include Printable
-      include Dry::Equalizer(:left, :right, :options, :meta, inspect: false, immutable: true)
-
-      # @return [Type]
-      attr_reader :left
-
-      # @return [Type]
-      attr_reader :right
-
-      # @api private
-      class Constrained < Sum
-        # @return [Dry::Logic::Operations::Or]
-        def rule
-          left.rule | right.rule
-        end
-
-        # @return [true]
-        def constrained?
-          true
-        end
-      end
-
-      # @param [Type] left
-      # @param [Type] right
-      # @param [Hash] options
-      #
-      # @api private
-      def initialize(left, right, **options)
-        super
-        @left, @right = left, right
-        freeze
-      end
+      include Composition
 
-      # @return [String]
-      #
-      # @api public
-      def name
-        [left, right].map(&:name).join(" | ")
-      end
-
-      # @return [false]
-      #
-      # @api public
-      def default?
-        false
-      end
-
-      # @return [false]
-      #
-      # @api public
-      def constrained?
-        false
+      def self.operator
+        :|
       end
 
       # @return [Boolean]
@@ -108,26 +52,6 @@ module Dry
         end
       end
 
-      # @api private
-      def success(input)
-        if left.valid?(input)
-          left.success(input)
-        elsif right.valid?(input)
-          right.success(input)
-        else
-          raise ArgumentError, "Invalid success value '#{input}' for #{inspect}"
-        end
-      end
-
-      # @api private
-      def failure(input, _error = nil)
-        if !left.valid?(input)
-          left.failure(input, left.try(input).error)
-        else
-          right.failure(input, right.try(input).error)
-        end
-      end
-
       # @param [Object] value
       #
       # @return [Boolean]
@@ -153,13 +77,6 @@ module Dry
         end
       end
 
-      # @see Nominal#to_ast
-      #
-      # @api public
-      def to_ast(meta: true)
-        [:sum, [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
-      end
-
       # @param [Hash] options
       #
       # @return [Constrained,Sum]
@@ -174,15 +91,6 @@ module Dry
           super
         end
       end
-
-      # Wrap the type with a proc
-      #
-      # @return [Proc]
-      #
-      # @api public
-      def to_proc
-        proc { |value| self.(value) }
-      end
     end
   end
 end

data/lib/dry/types/type.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require "dry/core/deprecations"
-
 module Dry
   module Types
     # Common Type module denoting an object is a Type
     #
     # @api public
     module Type
-      extend ::Dry::Core::Deprecations[:'dry-types']
+      extend ::Dry::Core::Deprecations[:"dry-types"]
 
       deprecate(:safe, :lax)
 

data/lib/dry/types/version.rb

@@ -2,6 +2,6 @@
 
 module Dry
   module Types
-    VERSION = "1.5.1"
+    VERSION = "1.7.2"
   end
 end

data/lib/dry/types.rb

@@ -3,36 +3,63 @@
 require "bigdecimal"
 require "date"
 require "set"
+require "zeitwerk"
 
 require "concurrent/map"
 
-require "dry/container"
-require "dry/core/extensions"
-require "dry/core/constants"
-require "dry/core/class_attributes"
+require "dry/core"
+require "dry/logic"
 
+require "dry/types/constraints"
+require "dry/types/errors"
 require "dry/types/version"
-require "dry/types/container"
+
+# This must be required explicitly as it may conflict with dry-inflector
 require "dry/types/inflector"
-require "dry/types/type"
-require "dry/types/printable"
-require "dry/types/nominal"
-require "dry/types/constructor"
 require "dry/types/module"
 
-require "dry/types/errors"
-
 module Dry
   # Main library namespace
   #
   # @api public
   module Types
-    extend Dry::Core::Extensions
-    extend Dry::Core::ClassAttributes
-    extend Dry::Core::Deprecations[:'dry-types']
-    include Dry::Core::Constants
+    extend ::Dry::Core::Extensions
+    extend ::Dry::Core::ClassAttributes
+    extend ::Dry::Core::Deprecations[:"dry-types"]
+    include ::Dry::Core::Constants
+
+    TYPE_SPEC_REGEX = /(.+)<(.+)>/
+
+    def self.loader
+      @loader ||= ::Zeitwerk::Loader.new.tap do |loader|
+        root = ::File.expand_path("..", __dir__)
+        loader.tag = "dry-types"
+        loader.inflector = ::Zeitwerk::GemInflector.new("#{root}/dry-types.rb")
+        loader.inflector.inflect("json" => "JSON")
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/dry-types.rb",
+          "#{root}/dry/types/extensions",
+          "#{root}/dry/types/printer",
+          "#{root}/dry/types/spec/types.rb",
+          "#{root}/dry/types/{#{%w[
+            compat
+            constraints
+            core
+            errors
+            extensions
+            inflector
+            module
+            json
+            params
+            printer
+            version
+          ].join(",")}}.rb"
+        )
+      end
+    end
 
-    TYPE_SPEC_REGEX = /(.+)<(.+)>/.freeze
+    loader.setup
 
     # @see Dry.Types
     def self.module(*namespaces, default: :nominal, **aliases)
@@ -120,7 +147,7 @@ module Dry
     #
     # @return [String]
     def self.identifier(klass)
-      Inflector.underscore(klass).tr("/", ".")
+      Types::Inflector.underscore(klass).tr("/", ".")
     end
 
     # Cached type map
@@ -134,7 +161,7 @@ module Dry
 
     # @api private
     def self.const_missing(const)
-      underscored = Inflector.underscore(const)
+      underscored = Types::Inflector.underscore(const)
 
       if container.keys.any? { |key| key.split(".")[0] == underscored }
         raise ::NameError,
@@ -180,7 +207,7 @@ module Dry
   #
   #   module Types
   #     # imports all types as constants, uses modules for namespaces
-  #     include Dry::Types()
+  #     include Dry.Types()
   #   end
   #   # strict types are exported by default
   #   Types::Integer
@@ -191,7 +218,7 @@ module Dry
   # @example changing default types
   #
   #   module Types
-  #     include Dry::Types(default: :nominal)
+  #     include Dry.Types(default: :nominal)
   #   end
   #   Types::Integer
   #   # => #<Dry::Types[Nominal<Integer>]>
@@ -199,7 +226,7 @@ module Dry
   # @example cherry-picking namespaces
   #
   #   module Types
-  #     include Dry::Types(:strict, :coercible)
+  #     include Dry.Types(:strict, :coercible)
   #   end
   #   # cherry-picking discards default types,
   #   # provide the :default option along with the list of
@@ -208,7 +235,7 @@ module Dry
   #
   # @example custom names
   #   module Types
-  #     include Dry::Types(coercible: :Kernel)
+  #     include Dry.Types(coercible: :Kernel)
   #   end
   #   Types::Kernel::Integer
   #   # => #<Dry::Types[Constructor<Nominal<Integer> fn=Kernel.Integer>]>