dry-types 0.14.1 → 1.5.1

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

data/lib/dry/types/result.rb

@@ -1,54 +1,80 @@
-require 'dry/equalizer'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
 
 module Dry
   module Types
+    # Result class used by {Type#try}
+    #
+    # @api public
     class Result
-      include Dry::Equalizer(:input)
+      include ::Dry::Equalizer(:input, immutable: true)
 
       # @return [Object]
       attr_reader :input
 
       # @param [Object] input
+      #
+      # @api private
       def initialize(input)
         @input = input
       end
 
+      # Success result
+      #
+      # @api public
       class Success < Result
         # @return [true]
+        #
+        # @api public
         def success?
           true
         end
 
         # @return [false]
+        #
+        # @api public
         def failure?
           false
         end
       end
 
+      # Failure result
+      #
+      # @api public
       class Failure < Result
-        include Dry::Equalizer(:input, :error)
+        include ::Dry::Equalizer(:input, :error, immutable: true)
 
         # @return [#to_s]
         attr_reader :error
 
         # @param [Object] input
+        #
         # @param [#to_s] error
+        #
+        # @api private
         def initialize(input, error)
           super(input)
           @error = error
         end
 
         # @return [String]
+        #
+        # @api private
         def to_s
           error.to_s
         end
 
         # @return [false]
+        #
+        # @api public
         def success?
           false
         end
 
         # @return [true]
+        #
+        # @api public
         def failure?
           true
         end

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

@@ -0,0 +1,156 @@
+# 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
+    #
+    # @api public
+    class Schema < Hash
+      # Proxy type for schema keys. Contains only key name and
+      # whether it's required or not. All other calls deletaged
+      # to the wrapped type.
+      #
+      # @see Dry::Types::Schema
+      class Key
+        extend ::Dry::Core::Deprecations[:'dry-types']
+        include Type
+        include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
+        include Decorator
+        include Builder
+        include Printable
+
+        # @return [Symbol]
+        attr_reader :name
+
+        # @api private
+        def initialize(type, name, required: Undefined, **options)
+          required = Undefined.default(required) do
+            type.meta.fetch(:required) { !type.meta.fetch(:omittable, false) }
+          end
+
+          unless name.is_a?(::Symbol)
+            raise ArgumentError, "Schemas can only contain symbol keys, #{name.inspect} given"
+          end
+
+          super(type, name, required: required, **options)
+          @name = name
+        end
+
+        # @api private
+        def call_safe(input, &block)
+          type.call_safe(input, &block)
+        end
+
+        # @api private
+        def call_unsafe(input)
+          type.call_unsafe(input)
+        end
+
+        # @see Dry::Types::Nominal#try
+        #
+        # @api public
+        def try(input, &block)
+          type.try(input, &block)
+        end
+
+        # Whether the key is required in schema input
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def required?
+          options.fetch(:required)
+        end
+
+        # Control whether the key is required
+        #
+        # @overload required
+        #   @return [Boolean]
+        #
+        # @overload required(required)
+        #   Change key's "requireness"
+        #
+        #   @param [Boolean] required New value
+        #   @return [Dry::Types::Schema::Key]
+        #
+        # @api public
+        def required(required = Undefined)
+          if Undefined.equal?(required)
+            options.fetch(:required)
+          else
+            with(required: required)
+          end
+        end
+
+        # Make key not required
+        #
+        # @return [Dry::Types::Schema::Key]
+        #
+        # @api public
+        def omittable
+          required(false)
+        end
+
+        # Turn key into a lax type. Lax types are not strict hence such keys are not required
+        #
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          __new__(type.lax).required(false)
+        end
+
+        # Make wrapped type optional
+        #
+        # @return [Key]
+        #
+        # @api public
+        def optional
+          __new__(type.optional)
+        end
+
+        # Dump to internal AST representation
+        #
+        # @return [Array]
+        #
+        # @api public
+        def to_ast(meta: true)
+          [
+            :key,
+            [
+              name,
+              required,
+              type.to_ast(meta: meta)
+            ]
+          ]
+        end
+
+        # @see Dry::Types::Meta#meta
+        #
+        # @api public
+        def meta(data = Undefined)
+          if Undefined.equal?(data) || !data.key?(:omittable)
+            super
+          else
+            self.class.warn(
+              "Using meta for making schema keys is deprecated, " \
+              "please use .omittable or .required(false) instead" \
+              "\n" + Core::Deprecations::STACK.()
+            )
+            super.required(!data[:omittable])
+          end
+        end
+
+        private
+
+        # @api private
+        def decorate?(response)
+          response.is_a?(Type)
+        end
+      end
+    end
+  end
+end