dry-types 1.8.3 → 1.9.0

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2023 dry-rb team
+Copyright (c) 2015-2026 Hanakai team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

data/README.md

@@ -1,23 +1,17 @@
-<!--- this file is synced from dry-rb/template-gem project -->
+<!--- This file is synced from hanakai-rb/repo-sync -->
 
-[gem]: https://rubygems.org/gems/dry-types
+[rubygem]: https://rubygems.org/gems/dry-types
 [actions]: https://github.com/dry-rb/dry-types/actions
 
-# dry-types [![Gem Version](https://badge.fury.io/rb/dry-types.svg)][gem] [![CI Status](https://github.com/dry-rb/dry-types/workflows/CI/badge.svg)][actions]
+# dry-types [![Gem Version](https://badge.fury.io/rb/dry-types.svg)][rubygem] [![CI Status](https://github.com/dry-rb/dry-types/workflows/CI/badge.svg)][actions]
 
 ## Links
 
-* [User documentation](https://dry-rb.org/gems/dry-types)
-* [API documentation](http://rubydoc.info/gems/dry-types)
-* [Forum](https://discourse.dry-rb.org)
-
-## Supported Ruby versions
-
-This library officially supports the following Ruby versions:
-
-* MRI `>= 3.1`
-* jruby `>= 9.4` (not tested on CI)
+- [User documentation](https://dry-rb.org/gems/dry-types)
+- [API documentation](http://rubydoc.info/gems/dry-types)
+- [Forum](https://discourse.dry-rb.org)
 
 ## License
 
 See `LICENSE` file.
+

data/dry-types.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# this file is synced from dry-rb/template-gem project
+# This file is synced from hanakai-rb/repo-sync. To update it, edit repo-sync.yml.
 
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
@@ -8,8 +8,8 @@ require "dry/types/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "dry-types"
-  spec.authors       = ["Piotr Solnica"]
-  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.authors       = ["Hanakai team"]
+  spec.email         = ["info@hanakai.org"]
   spec.license       = "MIT"
   spec.version       = Dry::Types::VERSION.dup
 
@@ -21,19 +21,25 @@ Gem::Specification.new do |spec|
   spec.executables   = []
   spec.require_paths = ["lib"]
 
-  spec.metadata["allowed_push_host"]     = "https://rubygems.org"
-  spec.metadata["changelog_uri"]         = "https://github.com/dry-rb/dry-types/blob/main/CHANGELOG.md"
-  spec.metadata["source_code_uri"]       = "https://github.com/dry-rb/dry-types"
-  spec.metadata["bug_tracker_uri"]       = "https://github.com/dry-rb/dry-types/issues"
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  spec.required_ruby_version = ">= 3.1"
-
-  # to update dependencies edit project.yml
-  spec.add_dependency "bigdecimal", "~> 3.0"
-  spec.add_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_dependency "dry-core", "~> 1.0"
-  spec.add_dependency "dry-inflector", "~> 1.0"
-  spec.add_dependency "dry-logic", "~> 1.4"
-  spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.extra_rdoc_files = ["README.md", "CHANGELOG.md", "LICENSE"]
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  spec.metadata["changelog_uri"]     = "https://github.com/dry-rb/dry-types/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"]   = "https://github.com/dry-rb/dry-types"
+  spec.metadata["bug_tracker_uri"]   = "https://github.com/dry-rb/dry-types/issues"
+  spec.metadata["funding_uri"]       = "https://github.com/sponsors/hanami"
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.add_runtime_dependency "bigdecimal", ">= 3.0"
+  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_runtime_dependency "dry-core", "~> 1.0"
+  spec.add_runtime_dependency "dry-inflector", "~> 1.0"
+  spec.add_runtime_dependency "dry-logic", "~> 1.4"
+  spec.add_runtime_dependency "zeitwerk", "~> 2.6"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "yard"
 end
+

data/lib/dry/types/any.rb

@@ -33,7 +33,7 @@ module Dry
       # @return [Array]
       #
       # @api public
-      def to_ast(meta: true) = [:any, meta ? self.meta : EMPTY_HASH]
+      def to_ast(meta: true) = [:any, meta_ast(meta)]
     end
 
     Any = AnyClass.new

data/lib/dry/types/array/member.rb

@@ -97,18 +97,16 @@ module Dry
         # @return [Lax]
         #
         # @api public
-        def lax
-          Lax.new(Member.new(primitive, **options, member: member.lax, meta: meta))
-        end
+        def lax = Lax.new(Member.new(primitive, **options, member: member.lax, meta: meta))
 
         # @see Nominal#to_ast
         #
         # @api public
         def to_ast(meta: true)
           if member.respond_to?(:to_ast)
-            [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+            [:array, [member.to_ast(meta: meta), meta_ast(meta)]]
           else
-            [:array, [member, meta ? self.meta : EMPTY_HASH]]
+            [:array, [member, meta_ast(meta)]]
           end
         end
 

data/lib/dry/types/builder.rb

@@ -50,7 +50,16 @@ module Dry
       # @return [Sum]
       #
       # @api public
-      def optional = Types["nil"] | self
+      def optional
+        nil_type =
+          if Types.use_namespaced_optionals && respond_to?(:namespace) && namespace
+            Types["#{namespace}.nil"]
+          else
+            Types["nil"]
+          end
+
+        nil_type | self
+      end
 
       # Turn a type into a constrained type
       #
@@ -77,8 +86,15 @@ module Dry
       def default(input = Undefined, options = EMPTY_HASH, &block)
         unless input.frozen? || options[:shared]
           where = Core::Deprecations::STACK.()
+
+          # There is a weird behaviour in JRuby where the source_location is mutated upon
+          # calling `inspect` on proc (see: https://github.com/jruby/jruby/issues/9110)
+          # To bypass this, we call inspect on the clone (but only for proc and JRuby).
+          # This should be fixes in JRuby 10.0.3.0.
+          obj = input.is_a?(Proc) && RUBY_ENGINE == "jruby" ? input.dup : input
+
           Core::Deprecations.warn(
-            "#{input.inspect} is mutable. " \
+            "#{obj.inspect} is mutable. " \
             "Be careful: types will return the same instance of the default " \
             "value every time. Call `.freeze` when setting the default " \
             "or pass `shared: true` to discard this warning." \

data/lib/dry/types/coercions/params.rb

@@ -89,8 +89,8 @@ module Dry
           else
             Integer(input)
           end
-        rescue ::ArgumentError, ::TypeError => e
-          CoercionError.handle(e, &)
+        rescue ::ArgumentError, ::TypeError => exception
+          CoercionError.handle(exception, &)
         end
 
         # @param [#to_f, Object] input
@@ -102,8 +102,8 @@ module Dry
         # @api public
         def self.to_float(input, &)
           Float(input)
-        rescue ::ArgumentError, ::TypeError => e
-          CoercionError.handle(e, &)
+        rescue ::ArgumentError, ::TypeError => exception
+          CoercionError.handle(exception, &)
         end
 
         # @param [#to_d, Object] input

data/lib/dry/types/coercions.rb

@@ -19,8 +19,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Date.parse(input)
-          rescue ::ArgumentError, ::RangeError => e
-            CoercionError.handle(e, &)
+          rescue ::ArgumentError, ::RangeError => exception
+            CoercionError.handle(exception, &)
           end
         elsif input.is_a?(::Date)
           input
@@ -42,8 +42,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::DateTime.parse(input)
-          rescue ::ArgumentError => e
-            CoercionError.handle(e, &)
+          rescue ::ArgumentError => exception
+            CoercionError.handle(exception, &)
           end
         elsif input.is_a?(::DateTime)
           input
@@ -65,8 +65,8 @@ module Dry
         if input.respond_to?(:to_str)
           begin
             ::Time.parse(input)
-          rescue ::ArgumentError => e
-            CoercionError.handle(e, &)
+          rescue ::ArgumentError => exception
+            CoercionError.handle(exception, &)
           end
         elsif input.is_a?(::Time)
           input
@@ -86,8 +86,8 @@ module Dry
       # @api public
       def to_symbol(input, &)
         input.to_sym
-      rescue ::NoMethodError => e
-        CoercionError.handle(e, &)
+      rescue ::NoMethodError => exception
+        CoercionError.handle(exception, &)
       end
 
       private

data/lib/dry/types/compiler.rb

@@ -37,13 +37,20 @@ module Dry
       deprecate(:visit_safe, :visit_lax)
 
       def visit_nominal(node)
-        type, meta = node
+        type, options, meta =
+          case node
+          in [type, options, meta]
+            node
+          in [type, meta]
+            [type, EMPTY_HASH, meta]
+          end
+
         nominal_name = "nominal.#{Types.identifier(type)}"
 
         if registry.registered?(nominal_name)
-          registry[nominal_name].meta(meta)
+          registry[nominal_name].with(**options).meta(meta)
         else
-          Nominal.new(type, meta: meta)
+          Nominal.new(type, meta: meta, **options)
         end
       end
 

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

@@ -15,8 +15,8 @@ module Dry
         class Safe < Function
           def call(input, &)
             @fn.(input)
-          rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-            CoercionError.handle(e, &)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+            CoercionError.handle(exception, &)
           end
         end
 
@@ -92,8 +92,8 @@ module Dry
           class PrivateSafeCall < PrivateCall
             def call(input, &)
               @target.send(@name, input)
-            rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-              CoercionError.handle(e, &)
+            rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+              CoercionError.handle(exception, &)
             end
           end
 
@@ -120,8 +120,8 @@ module Dry
           # @return [Object]
           def call(input, type, &)
             @fn.(input, type, &)
-          rescue ::NoMethodError, ::TypeError, ::ArgumentError => e
-            CoercionError.handle(e, &)
+          rescue ::NoMethodError, ::TypeError, ::ArgumentError => exception
+            CoercionError.handle(exception, &)
           end
           alias_method :[], :call
 

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

@@ -24,8 +24,8 @@ module Dry
         # @api public
         def try(input, &)
           value = fn.(input, type)
-        rescue CoercionError => e
-          failure = failure(input, e)
+        rescue CoercionError => exception
+          failure = failure(input, exception)
           block_given? ? yield(failure) : failure
         else
           type.try(value, &)

data/lib/dry/types/constructor.rb

@@ -15,7 +15,7 @@ module Dry
       # @return [Type]
       attr_reader :type
 
-      undef :constrained?, :meta, :optional?, :primitive, :default?, :name
+      undef :constrained?, :meta, :optional?, :primitive, :primitive?, :default?, :name, :namespace
 
       # @param [Builder, Object] input
       # @param [Hash] options
@@ -55,7 +55,7 @@ module Dry
       # Instantiate a new constructor type instance
       #
       # @param [Type] type
-      # @param [Function] fn
+      # @option [Function] fn
       # @param [Hash] options
       #
       # @api private
@@ -88,8 +88,8 @@ module Dry
       # @api public
       def try(input, &)
         value = fn.(input)
-      rescue CoercionError => e
-        failure = failure(input, e)
+      rescue CoercionError => exception
+        failure = failure(input, exception)
         block_given? ? yield(failure) : failure
       else
         type.try(value, &)

data/lib/dry/types/hash.rb

@@ -94,8 +94,8 @@ module Dry
       # @api public
       def to_ast(meta: true)
         [:hash,
-         [options.slice(:type_transform_fn),
-          meta ? self.meta : EMPTY_HASH]]
+         [options.slice(:type_transform_fn, :namespace),
+          meta_ast(meta)]]
       end
 
       private
@@ -117,7 +117,7 @@ module Dry
         case type
         when Type then type
         when ::Class, ::String then Types[type]
-        else type # rubocop:disable Lint/DuplicateBranch
+        else type
         end
       end
 

data/lib/dry/types/map.rb

@@ -81,7 +81,7 @@ module Dry
         [:map,
          [key_type.to_ast(meta: true),
           value_type.to_ast(meta: true),
-          meta ? self.meta : EMPTY_HASH]]
+          meta_ast(meta)]]
       end
 
       # @return [Boolean]

data/lib/dry/types/meta.rb

@@ -16,7 +16,13 @@ module Dry
       # @return [Type]
       #
       # @api public
-      def with(**options) = super(meta: @meta, **options)
+      def with(**options)
+        if options.empty?
+          self
+        else
+          super(meta: @meta, **options)
+        end
+      end
 
       # @overload meta
       #   @return [Hash] metadata associated with type

data/lib/dry/types/nominal.rb

@@ -18,6 +18,9 @@ module Dry
       # @return [Class]
       attr_reader :primitive
 
+      # @return [String, nil]
+      attr_reader :namespace
+
       # @param [Class] primitive
       #
       # @return [Type]
@@ -42,6 +45,7 @@ module Dry
       def initialize(primitive, **options)
         super
         @primitive = primitive
+        @namespace = options[:namespace]
         freeze
       end
 
@@ -152,7 +156,7 @@ module Dry
       #
       # @api public
       def to_ast(meta: true)
-        [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
+        [:nominal, [primitive, namespace_ast, meta_ast(meta)]]
       end
 
       # Return self. Nominal types are lax by definition
@@ -168,6 +172,26 @@ module Dry
       #
       # @api public
       def to_proc = ALWAYS
+
+      private
+
+      # @api private
+      def namespace_ast
+        if @namespace
+          {namespace: @namespace}
+        else
+          EMPTY_HASH
+        end
+      end
+
+      # @api private
+      def meta_ast(meta)
+        if meta
+          self.meta
+        else
+          EMPTY_HASH
+        end
+      end
     end
 
     extend ::Dry::Core::Deprecations[:"dry-types"]

data/lib/dry/types/options.rb

@@ -23,7 +23,11 @@ module Dry
       #
       # @api private
       def with(**new_options)
-        self.class.new(*@__args__, **options, **new_options)
+        if new_options.empty?
+          self
+        else
+          self.class.new(*@__args__, **options, **new_options)
+        end
       end
     end
   end

data/lib/dry/types/params.rb

@@ -4,63 +4,34 @@ require "dry/types/coercions/params"
 
 module Dry
   module Types
-    register("params.nil") do
-      self["nominal.nil"].constructor(Coercions::Params.method(:to_nil))
-    end
-
-    register("params.date") do
-      self["nominal.date"].constructor(Coercions::Params.method(:to_date))
-    end
-
-    register("params.date_time") do
-      self["nominal.date_time"].constructor(Coercions::Params.method(:to_date_time))
-    end
-
-    register("params.time") do
-      self["nominal.time"].constructor(Coercions::Params.method(:to_time))
-    end
-
-    register("params.true") do
-      self["nominal.true"].constructor(Coercions::Params.method(:to_true))
-    end
-
-    register("params.false") do
-      self["nominal.false"].constructor(Coercions::Params.method(:to_false))
+    options = {namespace: "params"}
+
+    {
+      "nil" => :to_nil,
+      "date" => :to_date,
+      "date_time" => :to_date_time,
+      "time" => :to_time,
+      "true" => :to_true,
+      "false" => :to_false,
+      "integer" => :to_int,
+      "float" => :to_float,
+      "decimal" => :to_decimal,
+      "array" => :to_ary,
+      "hash" => :to_hash,
+      "symbol" => :to_symbol
+    }.each do |name, method|
+      register("params.#{name}") do
+        self["nominal.#{name}"].with(**options).constructor(Coercions::Params.method(method))
+      end
     end
 
     register("params.bool") do
       self["params.true"] | self["params.false"]
     end
 
-    register("params.integer") do
-      self["nominal.integer"].constructor(Coercions::Params.method(:to_int))
-    end
-
-    register("params.float") do
-      self["nominal.float"].constructor(Coercions::Params.method(:to_float))
-    end
-
-    register("params.decimal") do
-      self["nominal.decimal"].constructor(Coercions::Params.method(:to_decimal))
-    end
-
-    register("params.array") do
-      self["nominal.array"].constructor(Coercions::Params.method(:to_ary))
-    end
-
-    register("params.hash") do
-      self["nominal.hash"].constructor(Coercions::Params.method(:to_hash))
-    end
-
-    register("params.symbol") do
-      self["nominal.symbol"].constructor(Coercions::Params.method(:to_symbol))
-    end
-
-    register("params.string", self["string"])
+    register("params.string", self["string"].with(**options))
 
     COERCIBLE.each_key do |name|
-      next if name.equal?(:string)
-
       register("optional.params.#{name}", self["params.nil"] | self["params.#{name}"])
     end
   end

data/lib/dry/types/predicate_inferrer.rb

@@ -137,7 +137,7 @@ module Dry
           left = visit(left_node)
           right = visit(right_node)
 
-          if left.eql?(NIL) # rubocop:disable Lint/DeprecatedConstants
+          if left.eql?(NIL)
             right
           else
             [[left, right]]

data/lib/dry/types/primitive_inferrer.rb

@@ -19,10 +19,7 @@ module Dry
         end
 
         # @api private
-        def visit_nominal(node)
-          type, _ = node
-          type
-        end
+        def visit_nominal(node) = node[0]
 
         # @api private
         def visit_hash(_) = ::Hash
@@ -35,16 +32,10 @@ module Dry
         def visit_lax(node) = visit(node)
 
         # @api private
-        def visit_constructor(node)
-          other, * = node
-          visit(other)
-        end
+        def visit_constructor(node) = visit(node[0])
 
         # @api private
-        def visit_enum(node)
-          other, * = node
-          visit(other)
-        end
+        def visit_enum(node) = visit(node[0])
 
         # @api private
         def visit_sum(node)
@@ -54,10 +45,7 @@ module Dry
         end
 
         # @api private
-        def visit_constrained(node)
-          other, * = node
-          visit(other)
-        end
+        def visit_constrained(node) = visit(node[0])
 
         # @api private
         def visit_any(_) = ::Object

data/lib/dry/types/printer.rb

@@ -105,6 +105,22 @@ module Dry
         @composition_printers[klass].visit(composition, &)
       end
 
+      def visit_sum_constructors(sum)
+        visit_sum_constructor(sum.left) do |left|
+          visit_sum_constructor(sum.right) do |right|
+            yield "#{left} #{sum.class.operator} #{right}"
+          end
+        end
+      end
+
+      def visit_sum_constructor(type, &)
+        if type.is_a?(Dry::Types::Sum)
+          visit_sum_constructors(type, &)
+        else
+          visit(type, &)
+        end
+      end
+
       def visit_enum(enum)
         visit(enum.type) do |type|
           options = enum.options.dup
@@ -163,7 +179,7 @@ module Dry
           elsif path
             yield "#{path.sub("#{Dir.pwd}/", EMPTY_STRING)}:#{line}"
           else
-            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/) # rubocop:disable Lint/MixedRegexpCaptureTypes
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
 
             if match
               yield ".#{match[:name]}"

data/lib/dry/types/schema.rb

@@ -148,8 +148,8 @@ module Dry
         [
           :schema,
           [keys.map { |key| key.to_ast(meta: meta) },
-           options.slice(:key_transform_fn, :type_transform_fn, :strict),
-           meta ? self.meta : EMPTY_HASH]
+           options.slice(:key_transform_fn, :type_transform_fn, :strict, :namespace),
+           meta_ast(meta)]
         ]
       end
 
@@ -167,7 +167,7 @@ module Dry
       # @return [Schema]
       #
       # @api public
-      def strict(strict = true) # rubocop:disable Style/OptionalBooleanParameter
+      def strict(strict = true)
         with(strict: strict)
       end
 
@@ -326,10 +326,10 @@ module Dry
           if type
             begin
               result[k] = type.call_unsafe(value)
-            rescue ConstraintError => e
-              raise SchemaError.new(type.name, value, e.result)
-            rescue CoercionError => e
-              raise SchemaError.new(type.name, value, e.message)
+            rescue ConstraintError => exception
+              raise SchemaError.new(type.name, value, exception.result)
+            rescue CoercionError => exception
+              raise SchemaError.new(type.name, value, exception.message)
             end
           elsif strict?
             raise unexpected_keys(hash.keys)