dry-types 0.14.1 → 1.5.1

data/lib/dry/types/options.rb

@@ -1,42 +1,29 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for types with options
+    #
+    # @api private
     module Options
       # @return [Hash]
       attr_reader :options
 
-      # @see Definition#initialize
-      def initialize(*args, meta: EMPTY_HASH, **options)
+      # @see Nominal#initialize
+      #
+      # @api private
+      def initialize(*args, **options)
         @__args__ = args.freeze
         @options = options.freeze
-        @meta = meta.freeze
       end
 
       # @param [Hash] new_options
+      #
       # @return [Type]
-      def with(new_options)
-        self.class.new(*@__args__, **options, meta: @meta, **new_options)
-      end
-
-      # @overload meta
-      #   @return [Hash] metadata associated with type
       #
-      # @overload meta(data)
-      #   @param [Hash] new metadata to merge into existing metadata
-      #   @return [Type] new type with added metadata
-      def meta(data = nil)
-        if !data
-          @meta
-        elsif data.empty?
-          self
-        else
-          with(meta: @meta.merge(data))
-        end
-      end
-
-      # Resets meta
-      # @return [Dry::Types::Type]
-      def pristine
-        with(meta: EMPTY_HASH)
+      # @api private
+      def with(**new_options)
+        self.class.new(*@__args__, **options, **new_options)
       end
     end
   end

data/lib/dry/types/params.rb

@@ -1,53 +1,67 @@
-require 'dry/types/coercions/params'
+# frozen_string_literal: true
+
+require "dry/types/coercions/params"
 
 module Dry
   module Types
-    register('params.nil') do
-      self['nil'].constructor(Coercions::Params.method(:to_nil))
+    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') do
-      self['date'].constructor(Coercions::Params.method(:to_date))
+    register("params.date_time") do
+      self["nominal.date_time"].constructor(Coercions::Params.method(:to_date_time))
     end
 
-    register('params.date_time') do
-      self['date_time'].constructor(Coercions::Params.method(:to_date_time))
+    register("params.time") do
+      self["nominal.time"].constructor(Coercions::Params.method(:to_time))
     end
 
-    register('params.time') do
-      self['time'].constructor(Coercions::Params.method(:to_time))
+    register("params.true") do
+      self["nominal.true"].constructor(Coercions::Params.method(:to_true))
     end
 
-    register('params.true') do
-      self['true'].constructor(Coercions::Params.method(:to_true))
+    register("params.false") do
+      self["nominal.false"].constructor(Coercions::Params.method(:to_false))
     end
 
-    register('params.false') do
-      self['false'].constructor(Coercions::Params.method(:to_false))
+    register("params.bool") do
+      self["params.true"] | self["params.false"]
     end
 
-    register('params.bool') do
-      (self['params.true'] | self['params.false']).safe
+    register("params.integer") do
+      self["nominal.integer"].constructor(Coercions::Params.method(:to_int))
     end
 
-    register('params.integer') do
-      self['integer'].constructor(Coercions::Params.method(:to_int))
+    register("params.float") do
+      self["nominal.float"].constructor(Coercions::Params.method(:to_float))
     end
 
-    register('params.float') do
-      self['float'].constructor(Coercions::Params.method(:to_float))
+    register("params.decimal") do
+      self["nominal.decimal"].constructor(Coercions::Params.method(:to_decimal))
     end
 
-    register('params.decimal') do
-      self['decimal'].constructor(Coercions::Params.method(:to_decimal))
+    register("params.array") do
+      self["nominal.array"].constructor(Coercions::Params.method(:to_ary))
     end
 
-    register('params.array') do
-      self['array'].constructor(Coercions::Params.method(:to_ary)).safe
+    register("params.hash") do
+      self["nominal.hash"].constructor(Coercions::Params.method(:to_hash))
     end
 
-    register('params.hash') do
-      self['hash'].constructor(Coercions::Params.method(:to_hash)).safe
+    register("params.symbol") do
+      self["nominal.symbol"].constructor(Coercions::Params.method(:to_symbol))
+    end
+
+    register("params.string", self["string"])
+
+    COERCIBLE.each_key do |name|
+      next if name.equal?(:string)
+
+      register("optional.params.#{name}", self["params.nil"] | self["params.#{name}"])
     end
   end
 end

data/lib/dry/types/predicate_inferrer.rb

@@ -0,0 +1,238 @@
+# 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.
+    #
+    # @api public
+    class PredicateInferrer
+      extend Core::Cache
+
+      TYPE_TO_PREDICATE = {
+        ::DateTime => :date_time?,
+        ::Date => :date?,
+        ::Time => :time?,
+        ::FalseClass => :false?,
+        ::Integer => :int?,
+        ::Float => :float?,
+        ::NilClass => :nil?,
+        ::String => :str?,
+        ::TrueClass => :true?,
+        ::BigDecimal => :decimal?,
+        ::Array => :array?
+      }.freeze
+
+      REDUCED_TYPES = {
+        [[[:true?], [:false?]]] => %i[bool?]
+      }.freeze
+
+      HASH = %i[hash?].freeze
+
+      ARRAY = %i[array?].freeze
+
+      NIL = %i[nil?].freeze
+
+      # Compiler reduces type AST into a list of predicates
+      #
+      # @api private
+      class Compiler
+        extend Core::ClassAttributes
+
+        defines :infer_predicate_by_class_name
+        infer_predicate_by_class_name nil
+
+        # @return [PredicateRegistry]
+        # @api private
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @api private
+        def infer_predicate(type)
+          pred = TYPE_TO_PREDICATE.fetch(type) do
+            if type.name.nil? || self.class.infer_predicate_by_class_name.equal?(false)
+              nil
+            else
+              candidate = :"#{type.name.split("::").last.downcase}?"
+
+              if registry.key?(candidate)
+                if self.class.infer_predicate_by_class_name
+                  candidate
+                else
+                  raise ::KeyError, <<~MESSAGE
+                    Automatic predicate inferring from class names is deprecated
+                    and will be removed in dry-types 2.0.
+                    Use `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name true`
+                    to restore the previous behavior
+                    or `Dry::Types::PredicateInferrer::Compiler.infer_predicate_by_class_name false`
+                    to explicitly opt-out (i.e. no exception + no inferring).
+                    Note: for dry-schema and dry-validation use Dry::Schema::PredicateInferrer::Compiler.
+                  MESSAGE
+                end
+              else
+                nil
+              end
+            end
+          end
+
+          if pred.nil?
+            EMPTY_ARRAY
+          else
+            [pred]
+          end
+        end
+
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type = node[0]
+          predicate = infer_predicate(type)
+
+          if !predicate.empty? && registry.key?(predicate[0])
+            predicate
+          else
+            [type?: type]
+          end
+        end
+
+        # @api private
+        def visit_hash(_)
+          HASH
+        end
+        alias_method :visit_schema, :visit_hash
+
+        # @api private
+        def visit_array(_)
+          ARRAY
+        end
+
+        # @api private
+        def visit_lax(node)
+          visit(node)
+        end
+
+        # @api private
+        def visit_constructor(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_enum(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_sum(node)
+          left_node, right_node, = node
+          left = visit(left_node)
+          right = visit(right_node)
+
+          if left.eql?(NIL)
+            right
+          else
+            [[left, right]]
+          end
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, rules = node
+          predicates = visit(rules)
+
+          if predicates.empty?
+            visit(other)
+          else
+            [*visit(other), *merge_predicates(predicates)]
+          end
+        end
+
+        # @api private
+        def visit_any(_)
+          EMPTY_ARRAY
+        end
+
+        # @api private
+        def visit_and(node)
+          left, right = node
+          visit(left) + visit(right)
+        end
+
+        # @api private
+        def visit_predicate(node)
+          pred, args = node
+
+          if pred.equal?(:type?)
+            EMPTY_ARRAY
+          elsif registry.key?(pred)
+            *curried, _ = args
+            values = curried.map { |_, v| v }
+
+            if values.empty?
+              [pred]
+            else
+              [pred => values[0]]
+            end
+          else
+            EMPTY_ARRAY
+          end
+        end
+
+        private
+
+        # @api private
+        def merge_predicates(nodes)
+          preds, merged = nodes.each_with_object([[], {}]) do |predicate, (ps, h)|
+            if predicate.is_a?(::Hash)
+              h.update(predicate)
+            else
+              ps << predicate
+            end
+          end
+
+          merged.empty? ? preds : [*preds, merged]
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize(registry = PredicateRegistry.new)
+        @compiler = Compiler.new(registry)
+      end
+
+      # Infer predicate identifier from the provided type
+      #
+      # @param [Type] type
+      # @return [Symbol]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          predicates = compiler.visit(type.to_ast)
+
+          if predicates.is_a?(::Hash)
+            predicates
+          else
+            REDUCED_TYPES[predicates] || predicates
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/predicate_registry.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "dry/logic/predicates"
+
+module Dry
+  module Types
+    # A registry with predicate objects from `Dry::Logic::Predicates`
+    #
+    # @api private
+    class PredicateRegistry
+      # @api private
+      attr_reader :predicates
+
+      # @api private
+      attr_reader :has_predicate
+
+      # @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]
+      end
+
+      # @api private
+      def key?(name)
+        has_predicate.(name)
+      end
+    end
+  end
+end

data/lib/dry/types/primitive_inferrer.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "dry/core/cache"
+
+module Dry
+  module Types
+    # PrimitiveInferrer returns the list of classes matching a type.
+    #
+    # @api public
+    class PrimitiveInferrer
+      extend Core::Cache
+
+      # Compiler reduces type AST into a list of primitives
+      #
+      # @api private
+      class Compiler
+        # @api private
+        def visit(node)
+          meth, rest = node
+          public_send(:"visit_#{meth}", rest)
+        end
+
+        # @api private
+        def visit_nominal(node)
+          type, _ = node
+          type
+        end
+
+        # @api private
+        def visit_hash(_)
+          ::Hash
+        end
+        alias_method :visit_schema, :visit_hash
+
+        # @api private
+        def visit_array(_)
+          ::Array
+        end
+
+        # @api private
+        def visit_lax(node)
+          visit(node)
+        end
+
+        # @api private
+        def visit_constructor(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_enum(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_sum(node)
+          left, right = node
+
+          [visit(left), visit(right)].flatten(1)
+        end
+
+        # @api private
+        def visit_constrained(node)
+          other, * = node
+          visit(other)
+        end
+
+        # @api private
+        def visit_any(_)
+          ::Object
+        end
+      end
+
+      # @return [Compiler]
+      # @api private
+      attr_reader :compiler
+
+      # @api private
+      def initialize
+        @compiler = Compiler.new
+      end
+
+      # Infer primitives from the provided type
+      #
+      # @return [Array[Class]]
+      #
+      # @api private
+      def [](type)
+        self.class.fetch_or_store(type) do
+          Array(compiler.visit(type.to_ast)).freeze
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/printable.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    module Printable
+      # @return [String]
+      #
+      # @api private
+      def to_s
+        PRINTER.(self) { super }
+      end
+      alias_method :inspect, :to_s
+    end
+  end
+end