dry-types 0.13.2 → 1.5.1

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

data/lib/dry/types/printer.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # @api private
+    class Printer
+      MAPPING = {
+        Nominal => :visit_nominal,
+        Constructor => :visit_constructor,
+        Constrained => :visit_constrained,
+        Constrained::Coercible => :visit_constrained,
+        Hash => :visit_hash,
+        Schema => :visit_schema,
+        Schema::Key => :visit_key,
+        Map => :visit_map,
+        Array => :visit_array,
+        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,
+        Any.class => :visit_any
+      }
+
+      def call(type)
+        output = "".dup
+        visit(type) { |str| output << str }
+        "#<Dry::Types[#{output}]>"
+      end
+
+      def visit(type, &block)
+        print_with = MAPPING.fetch(type.class) do
+          if type.class < Constructor
+            :visit_constructor
+          elsif type.is_a?(Type)
+            return yield type.inspect
+          else
+            raise ArgumentError, "Do not know how to print #{type.class}"
+          end
+        end
+        send(print_with, type, &block)
+      end
+
+      def visit_any(_)
+        yield "Any"
+      end
+
+      def visit_array(type)
+        visit_options(EMPTY_HASH, type.meta) do |opts|
+          yield "Array#{opts}"
+        end
+      end
+
+      def visit_array_member(array)
+        visit(array.member) do |type|
+          visit_options(EMPTY_HASH, array.meta) do |opts|
+            yield "Array<#{type}#{opts}>"
+          end
+        end
+      end
+
+      def visit_constructor(constructor)
+        visit(constructor.type) do |type|
+          visit_callable(constructor.fn.fn) do |fn|
+            options = constructor.options.dup
+            options.delete(:fn)
+
+            visit_options(options) do |opts|
+              yield "Constructor<#{type} fn=#{fn}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_constrained(constrained)
+        visit(constrained.type) do |type|
+          options = constrained.options.dup
+          rule = options.delete(:rule)
+
+          visit_options(options) do |_opts|
+            yield "Constrained<#{type} rule=[#{rule}]>"
+          end
+        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
+      end
+
+      def visit_enum(enum)
+        visit(enum.type) do |type|
+          options = enum.options.dup
+          mapping = options.delete(:mapping)
+
+          visit_options(options) do |opts|
+            if mapping == enum.inverted_mapping
+              values = mapping.values.map(&:inspect).join(", ")
+              yield "Enum<#{type} values={#{values}}#{opts}>"
+            else
+              mapping_str = mapping.map { |key, value|
+                "#{key.inspect}=>#{value.inspect}"
+              }.join(", ")
+              yield "Enum<#{type} mapping={#{mapping_str}}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_default(default)
+        visit(default.type) do |type|
+          visit_options(default.options) do |opts|
+            if default.is_a?(Default::Callable)
+              visit_callable(default.value) do |fn|
+                yield "Default<#{type} value_fn=#{fn}#{opts}>"
+              end
+            else
+              yield "Default<#{type} value=#{default.value.inspect}#{opts}>"
+            end
+          end
+        end
+      end
+
+      def visit_nominal(type)
+        visit_options(type.options, type.meta) do |opts|
+          yield "Nominal<#{type.primitive}#{opts}>"
+        end
+      end
+
+      def visit_lax(lax)
+        visit(lax.type) do |type|
+          yield "Lax<#{type}>"
+        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
+
+        case fn
+        when ::Method
+          yield "#{fn.receiver}.#{fn.name}"
+        when ::Proc
+          path, line = fn.source_location
+
+          if line&.zero?
+            yield ".#{path}"
+          elsif path
+            yield "#{path.sub(Dir.pwd + "/", EMPTY_STRING)}:#{line}"
+          else
+            match = fn.to_s.match(/\A#<Proc:0x\h+\(&:(?<name>\w+)\)(:? \(lambda\))?>\z/)
+
+            if match
+              yield ".#{match[:name]}"
+            elsif fn.lambda?
+              yield "(lambda)"
+            else
+              yield "(proc)"
+            end
+          end
+        else
+          call = fn.method(:call)
+
+          if call.owner == fn.class
+            yield "#{fn.class}#call"
+          else
+            yield "#{fn}.call"
+          end
+        end
+      end
+
+      def visit_options(options, meta = EMPTY_HASH)
+        if options.empty? && meta.empty?
+          yield ""
+        else
+          opts = options.empty? ? "" : " options=#{options.inspect}"
+
+          if meta.empty?
+            yield opts
+          else
+            values = meta.map do |key, value|
+              case key
+              when Symbol
+                "#{key}: #{value.inspect}"
+              else
+                "#{key.inspect}=>#{value.inspect}"
+              end
+            end
+
+            yield "#{opts} meta={#{values.join(", ")}}"
+          end
+        end
+      end
+    end
+
+    PRINTER = Printer.new.freeze
+  end
+end