dry-types 0.13.2 → 1.5.1

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

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

@@ -1,94 +1,164 @@
-RSpec.shared_examples_for 'Dry::Types::Definition without primitive' do
+# 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
-    it 'returns a boolean value' do
+  describe "#constrained?" do
+    it "returns a boolean value" do
       expect(type.constrained?).to be_boolean
     end
   end
 
-  describe '#default?' do
-    it 'returns a boolean value' do
+  describe "#default?" do
+    it "returns a boolean value" do
       expect(type.default?).to be_boolean
     end
   end
 
-  describe '#valid?' do
-    it 'returns a boolean value' do
+  describe "#valid?" do
+    it "returns a boolean value" do
       expect(type.valid?(1)).to be_boolean
     end
   end
 
-  describe '#eql?' do
-    it 'has #eql? defined' do
+  describe "#eql?" do
+    it "has #eql? defined" do
       expect(type).to eql(type)
     end
   end
 
-  describe '#==' do
-    it 'has #== defined' do
+  describe "#==" do
+    it "has #== defined" do
       expect(type).to eq(type)
     end
   end
 
-  describe '#optional?' do
-    it 'returns a boolean value' do
+  describe "#optional?" do
+    it "returns a boolean value" do
       expect(type.optional?).to be_boolean
     end
   end
+
+  describe "#to_s" do
+    it "returns a custom string representation" do
+      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
 
-RSpec.shared_examples_for 'Dry::Types::Definition#meta' do
-  describe '#meta' do
-    it 'allows setting meta information' do
-      with_meta = type.meta(foo: :bar).meta(baz: '1')
+RSpec.shared_examples_for "Dry::Types::Nominal#meta" do
+  describe "#meta" do
+    it "allows setting meta information" do
+      with_meta = type.meta(foo: :bar).meta(baz: "1")
 
       expect(with_meta).to be_instance_of(type.class)
-      expect(with_meta.meta).to eql(foo: :bar, baz: '1')
+      expect(with_meta.meta).to eql(foo: :bar, baz: "1")
     end
 
-    it 'equalizes on empty meta' do
+    it "equalizes on empty meta" do
       expect(type).to eql(type.meta({}))
     end
 
-    it 'equalizes on filled meta' do
-      expect(type).to_not eql(type.meta(i_am: 'different'))
+    it "equalizes on filled meta" do
+      expect(type).to_not eql(type.meta(i_am: "different"))
     end
 
-    it 'is locally immutable' do
+    it "is locally immutable" 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
 
-  describe '#pristine' do
-    it 'erases meta' do
+  describe "#pristine" do
+    it "erases meta" do
       expect(type.meta(foo: :bar).pristine).to eql(type)
     end
   end
 end
 
-RSpec.shared_examples_for Dry::Types::Definition do
-  it_behaves_like 'Dry::Types::Definition without primitive'
+RSpec.shared_examples_for Dry::Types::Nominal do
+  it_behaves_like "Dry::Types::Nominal without primitive"
 
-  describe '#primitive' do
-    it 'returns a class' do
+  describe "#primitive" do
+    it "returns a class" do
       expect(type.primitive).to be_instance_of(Class)
     end
   end
 
-  describe '#constructor' do
-    it 'returns a constructor' do
+  describe "#constructor" do
+    it "returns a constructor" do
       constructor = type.constructor(&:to_s)
 
       expect(constructor).to be_a(Dry::Types::Type)
     end
   end
 end
+
+RSpec.shared_examples_for "a constrained type" do |options = {inputs: Object.new}|
+  inputs = options[:inputs]
+
+  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
+
+  describe "#constructor" do
+    let(:wrapping_constructor) do
+      type.constructor { |input, type| type.(input) { fallback } }
+    end
+
+    it "can be wrapped" do
+      Array(inputs).each do |input|
+        expect(wrapping_constructor.(input)).to be(fallback)
+      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) { raise }).to be(input)
+        expect(type.(input)).to be(input)
+      end
+    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

data/lib/dry/types/sum.rb

@@ -1,12 +1,21 @@
-require 'dry/types/options'
+# frozen_string_literal: true
+
+require "dry/core/equalizer"
+require "dry/types/options"
+require "dry/types/meta"
 
 module Dry
   module Types
+    # Sum type
+    #
+    # @api public
     class Sum
       include Type
-      include Dry::Equalizer(:left, :right, :options, :meta)
       include Builder
       include Options
+      include Meta
+      include Printable
+      include Dry::Equalizer(:left, :right, :options, :meta, inspect: false, immutable: true)
 
       # @return [Type]
       attr_reader :left
@@ -14,6 +23,7 @@ module Dry
       # @return [Type]
       attr_reader :right
 
+      # @api private
       class Constrained < Sum
         # @return [Dry::Logic::Operations::Or]
         def rule
@@ -24,68 +34,81 @@ module Dry
         def constrained?
           true
         end
-
-        # @param [Object] input
-        # @return [Object]
-        # @raise [ConstraintError] if given +input+ not passing {#try}
-        def call(input)
-          try(input) do |result|
-            raise ConstraintError.new(result, input)
-          end.input
-        end
-        alias_method :[], :call
       end
 
       # @param [Type] left
       # @param [Type] right
       # @param [Hash] options
-      def initialize(left, right, options = {})
+      #
+      # @api private
+      def initialize(left, right, **options)
         super
         @left, @right = left, right
         freeze
       end
 
       # @return [String]
+      #
+      # @api public
       def name
-        [left, right].map(&:name).join(' | ')
+        [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?
-        left == Types['strict.nil']
+        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)
-        result = left.try(input) do
-          right.try(input)
-        end
 
-        return result if result.success?
+      # @param [Object] input
+      #
+      # @return [Object]
+      #
+      # @api private
+      def call_safe(input, &block)
+        left.call_safe(input) { right.call_safe(input, &block) }
+      end
 
-        if block
-          yield(result)
-        else
-          result
+      # @param [Object] input
+      #
+      # @api public
+      def try(input)
+        left.try(input) do
+          right.try(input) do |failure|
+            if block_given?
+              yield(failure)
+            else
+              failure
+            end
+          end
         end
       end
 
+      # @api private
       def success(input)
         if left.valid?(input)
           left.success(input)
@@ -96,6 +119,7 @@ module Dry
         end
       end
 
+      # @api private
       def failure(input, _error = nil)
         if !left.valid?(input)
           left.failure(input, left.try(input).error)
@@ -105,28 +129,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 = Undefined)
+        if Undefined.equal?(data)
+          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
       #
-      # @see Definition#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
@@ -134,6 +174,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