dry-types 1.1.1 → 1.3.1

data/lib/dry/types/predicate_inferrer.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'dry/core/cache'
+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?,
+        FalseClass => :false?,
+        Integer => :int?,
+        NilClass => :nil?,
+        String => :str?,
+        TrueClass => :true?,
+        BigDecimal => :decimal?
+      }.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
+        # @return [PredicateRegistry]
+        # @api private
+        attr_reader :registry
+
+        # @api private
+        def initialize(registry)
+          @registry = registry
+        end
+
+        # @api private
+        def infer_predicate(type)
+          [TYPE_TO_PREDICATE.fetch(type) { :"#{type.name.split('::').last.downcase}?" }]
+        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 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/result.rb

@@ -8,7 +8,7 @@ module Dry
     #
     # @api public
     class Result
-      include Dry::Equalizer(:input, inspect: false)
+      include ::Dry::Equalizer(:input, immutable: true)
 
       # @return [Object]
       attr_reader :input
@@ -43,7 +43,7 @@ module Dry
       #
       # @api public
       class Failure < Result
-        include Dry::Equalizer(:input, :error, inspect: false)
+        include ::Dry::Equalizer(:input, :error, immutable: true)
 
         # @return [#to_s]
         attr_reader :error

data/lib/dry/types/schema.rb

@@ -145,7 +145,7 @@ module Dry
       #
       # @api public
       def to_ast(meta: true)
-        if RUBY_VERSION >= "2.5"
+        if RUBY_VERSION >= '2.5'
           opts = options.slice(:key_transform_fn, :type_transform_fn, :strict)
         else
           opts = options.select { |k, _|
@@ -179,7 +179,7 @@ module Dry
         with(strict: strict)
       end
 
-      # Injects a key transformation function
+      # Inject a key transformation function
       #
       # @param [#call,nil] proc
       # @param [#call,nil] block
@@ -284,6 +284,27 @@ module Dry
         Lax.new(schema(keys.map(&:lax)))
       end
 
+      # Merge given schema keys into current schema
+      #
+      # A new instance is returned.
+      #
+      # @param schema [Schema]
+      # @return [Schema]
+      #
+      # @api public
+      def merge(other)
+        schema(other.keys)
+      end
+
+      # Empty schema with the same options
+      #
+      # @return [Schema]
+      #
+      # @api public
+      def clear
+        with(keys: EMPTY_ARRAY)
+      end
+
       private
 
       # @param [Array<Dry::Types::Schema::Keys>] keys

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

@@ -17,7 +17,7 @@ module Dry
       class Key
         extend ::Dry::Core::Deprecations[:'dry-types']
         include Type
-        include Dry::Equalizer(:name, :type, :options, inspect: false)
+        include Dry::Equalizer(:name, :type, :options, inspect: false, immutable: true)
         include Decorator
         include Builder
         include Printable
@@ -31,6 +31,10 @@ module Dry
             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
@@ -99,6 +103,15 @@ module Dry
           __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]
@@ -118,8 +131,8 @@ module Dry
         # @see Dry::Types::Meta#meta
         #
         # @api public
-        def meta(data = nil)
-          if data.nil? || !data.key?(:omittable)
+        def meta(data = Undefined)
+          if Undefined.equal?(data) || !data.key?(:omittable)
             super
           else
             self.class.warn(

data/lib/dry/types/spec/types.rb

@@ -109,7 +109,9 @@ RSpec.shared_examples_for Dry::Types::Nominal do
   end
 end
 
-RSpec.shared_examples_for 'a constrained type' do |inputs: Object.new|
+RSpec.shared_examples_for 'a constrained type' do |options = { inputs: Object.new }|
+  inputs = options[:inputs]
+
   let(:fallback) { Object.new }
 
   describe '#call' do
@@ -137,3 +139,14 @@ RSpec.shared_examples_for 'a nominal type' do |inputs: Object.new|
     end
   end
 end
+
+RSpec.shared_examples_for 'a composable constructor' do
+  describe '#constructor' do
+    it 'has aliases for composition' do
+      expect(type.method(:append)).to eql(type.method(:constructor))
+      expect(type.method(:prepend)).to eql(type.method(:constructor))
+      expect(type.method(:<<)).to eql(type.method(:constructor))
+      expect(type.method(:>>)).to eql(type.method(:constructor))
+    end
+  end
+end