dry-types 0.15.0 → 1.2.0

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

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 require 'dry/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
@@ -9,6 +15,7 @@ module Dry
       #
       # @see Dry::Types::Schema
       class Key
+        extend ::Dry::Core::Deprecations[:'dry-types']
         include Type
         include Dry::Equalizer(:name, :type, :options, inspect: false)
         include Decorator
@@ -28,12 +35,19 @@ module Dry
           @name = name
         end
 
-        # @see Dry::Types::Nominal#call
-        def call(input, &block)
-          type.(input, &block)
+        # @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
@@ -41,6 +55,8 @@ module Dry
         # Whether the key is required in schema input
         #
         # @return [Boolean]
+        #
+        # @api public
         def required?
           options.fetch(:required)
         end
@@ -55,6 +71,8 @@ module Dry
         #
         #   @param [Boolean] required New value
         #   @return [Dry::Types::Schema::Key]
+        #
+        # @api public
         def required(required = Undefined)
           if Undefined.equal?(required)
             options.fetch(:required)
@@ -66,36 +84,26 @@ module Dry
         # Make key not required
         #
         # @return [Dry::Types::Schema::Key]
+        #
+        # @api public
         def omittable
           required(false)
         end
 
-        # Construct a default type. Default values are
-        # evaluated/applied when key is absent in schema
-        # input.
+        # Turn key into a lax type. Lax types are not strict hence such keys are not required
         #
-        # @see Dry::Types::Default
-        # @return [Dry::Types::Schema::Key]
-        def default(input = Undefined, &block)
-          new(type.default(input, &block))
-        end
-
-        # Replace the underlying type
-        # @param [Dry::Types::Type] type
-        # @return [Dry::Types::Schema::Key]
-        def new(type)
-          self.class.new(type, name, options)
-        end
-
-        # @see Dry::Types::Safe
-        # @return [Dry::Types::Schema::Key]
-        def safe
-          new(type.safe)
+        # @return [Lax]
+        #
+        # @api public
+        def lax
+          __new__(type.lax).required(false)
         end
 
         # Dump to internal AST representation
         #
         # @return [Array]
+        #
+        # @api public
         def to_ast(meta: true)
           [
             :key,
@@ -107,23 +115,28 @@ module Dry
           ]
         end
 
-        # Get/set type metadata. The Key type doesn't have
-        # its out meta, it delegates these calls to the underlying
-        # type.
+        # @see Dry::Types::Meta#meta
         #
-        # @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
+        # @api public
         def meta(data = nil)
-          if data.nil?
-            type.meta
+          if data.nil? || !data.key?(:omittable)
+            super
           else
-            new(type.meta(data))
+            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

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 RSpec.shared_examples_for 'Dry::Types::Nominal without primitive' do
   def be_boolean
-    satisfy { |x| x == true || x == false  }
+    satisfy { |x| x == true || x == false }
   end
 
   describe '#constrained?' do
@@ -41,9 +43,15 @@ RSpec.shared_examples_for 'Dry::Types::Nominal without primitive' do
 
   describe '#to_s' do
     it 'returns a custom string representation' do
-      if type.class.name.start_with?('Dry::Types')
-        expect(type.to_s).to start_with('#<Dry::Types')
-      end
+      expect(type.to_s).to start_with('#<Dry::Types') if type.class.name.start_with?('Dry::Types')
+    end
+  end
+
+  describe '#to_proc' do
+    subject(:callable) { type.to_proc }
+
+    it 'converts a type to a proc' do
+      expect(callable).to be_a(Proc)
     end
   end
 end
@@ -69,9 +77,9 @@ RSpec.shared_examples_for 'Dry::Types::Nominal#meta' do
       expect(type.meta).to be_a ::Hash
       expect(type.meta).to be_frozen
       expect(type.meta).not_to have_key :immutable_test
-      derived = type.with(meta: {immutable_test: 1})
+      derived = type.meta(immutable_test: 1)
       expect(derived.meta).to be_frozen
-      expect(derived.meta).to eql({immutable_test: 1})
+      expect(derived.meta).to eql(immutable_test: 1)
       expect(type.meta).not_to have_key :immutable_test
     end
   end
@@ -100,3 +108,32 @@ RSpec.shared_examples_for Dry::Types::Nominal do
     end
   end
 end
+
+RSpec.shared_examples_for 'a constrained type' do |inputs: Object.new|
+  let(:fallback) { Object.new }
+
+  describe '#call' do
+    it 'yields a block on failure' do
+      Array(inputs).each do |input|
+        expect(type.(input) { fallback }).to be(fallback)
+      end
+    end
+
+    it 'throws an error on invalid input' do
+      Array(inputs).each do |input|
+        expect { type.(input) }.to raise_error(Dry::Types::CoercionError)
+      end
+    end
+  end
+end
+
+RSpec.shared_examples_for 'a nominal type' do |inputs: Object.new|
+  describe '#call' do
+    it 'always returns the input back' do
+      Array(inputs).each do |input|
+        expect(type.(input) { fail }).to be(input)
+        expect(type.(input)).to be(input)
+      end
+    end
+  end
+end

data/lib/dry/types/sum.rb

@@ -1,11 +1,18 @@
+# frozen_string_literal: true
+
 require 'dry/types/options'
+require 'dry/types/meta'
 
 module Dry
   module Types
+    # Sum type
+    #
+    # @api public
     class Sum
       include Type
       include Builder
       include Options
+      include Meta
       include Printable
       include Dry::Equalizer(:left, :right, :options, :meta, inspect: false)
 
@@ -15,6 +22,7 @@ module Dry
       # @return [Type]
       attr_reader :right
 
+      # @api private
       class Constrained < Sum
         # @return [Dry::Logic::Operations::Or]
         def rule
@@ -25,21 +33,13 @@ module Dry
         def constrained?
           true
         end
-
-        # @param [Object] input
-        # @return [Object]
-        # @raise [ConstraintError] if given +input+ not passing {#try}
-        def call(input)
-          try(input) { |result|
-            raise ConstraintError.new(result, input)
-          }.input
-        end
-        alias_method :[], :call
       end
 
       # @param [Type] left
       # @param [Type] right
       # @param [Hash] options
+      #
+      # @api private
       def initialize(left, right, options = {})
         super
         @left, @right = left, right
@@ -47,33 +47,55 @@ module Dry
       end
 
       # @return [String]
+      #
+      # @api public
       def name
         [left, right].map(&:name).join(' | ')
       end
 
       # @return [false]
+      #
+      # @api public
       def default?
         false
       end
 
       # @return [false]
+      #
+      # @api public
       def constrained?
         false
       end
 
       # @return [Boolean]
+      #
+      # @api public
       def optional?
         primitive?(nil)
       end
 
       # @param [Object] input
+      #
       # @return [Object]
-      def call(input)
-        try(input).input
+      #
+      # @api private
+      def call_unsafe(input)
+        left.call_safe(input) { right.call_unsafe(input) }
       end
-      alias_method :[], :call
 
-      def try(input, &block)
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        left.call_safe(input) { right.call_safe(input, &block) }
+      end
+
+      # @param [Object] input
+      #
+      # @api public
+      def try(input)
         left.try(input) do
           right.try(input) do |failure|
             if block_given?
@@ -85,6 +107,7 @@ module Dry
         end
       end
 
+      # @api private
       def success(input)
         if left.valid?(input)
           left.success(input)
@@ -95,6 +118,7 @@ module Dry
         end
       end
 
+      # @api private
       def failure(input, _error = nil)
         if !left.valid?(input)
           left.failure(input, left.try(input).error)
@@ -104,28 +128,44 @@ module Dry
       end
 
       # @param [Object] value
+      #
       # @return [Boolean]
+      #
+      # @api private
       def primitive?(value)
         left.primitive?(value) || right.primitive?(value)
       end
 
-      # @param [Object] value
-      # @return [Boolean]
-      def valid?(value)
-        left.valid?(value) || right.valid?(value)
+      # Manage metadata to the type. If the type is an optional, #meta delegates
+      # to the right branch
+      #
+      # @see [Meta#meta]
+      #
+      # @api public
+      def meta(data = nil)
+        if data.nil?
+          optional? ? right.meta : super
+        elsif optional?
+          self.class.new(left, right.meta(data), options)
+        else
+          super
+        end
       end
-      alias_method :===, :valid?
 
-      # @api public
-      #
       # @see Nominal#to_ast
+      #
+      # @api public
       def to_ast(meta: true)
         [:sum, [left.to_ast(meta: meta), right.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
       end
 
       # @param [Hash] options
+      #
       # @return [Constrained,Sum]
+      #
       # @see Builder#constrained
+      #
+      # @api public
       def constrained(options)
         if optional?
           right.constrained(options).optional
@@ -133,6 +173,15 @@ module Dry
           super
         end
       end
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        proc { |value| self.(value) }
+      end
     end
   end
 end

data/lib/dry/types/type.rb

@@ -1,6 +1,55 @@
+# frozen_string_literal: true
+
+require 'dry/core/deprecations'
+
 module Dry
   module Types
+    # Common Type module denoting an object is a Type
+    #
+    # @api public
     module Type
+      extend ::Dry::Core::Deprecations[:'dry-types']
+
+      deprecate(:safe, :lax)
+
+      # Whether a value is a valid member of the type
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def valid?(input = Undefined)
+        call_safe(input) { return false }
+        true
+      end
+      # Anything can be coerced matches
+      alias_method :===, :valid?
+
+      # Apply type to a value
+      #
+      # @overload call(input = Undefined)
+      #   Possibly unsafe coercion attempt. If a value doesn't
+      #   match the type, an exception will be raised.
+      #
+      #   @param [Object] input
+      #   @return [Object]
+      #
+      # @overload call(input = Undefined)
+      #   When a block is passed, {#call} will never throw an exception on
+      #   failed coercion, instead it will call the block.
+      #
+      #   @param [Object] input
+      #   @yieldparam [Object] output Partially coerced value
+      #   @return [Object]
+      #
+      # @api public
+      def call(input = Undefined, &block)
+        if block_given?
+          call_safe(input, &block)
+        else
+          call_unsafe(input)
+        end
+      end
+      alias_method :[], :call
     end
   end
 end