dry-types 0.9.0 → 0.15.0

data/lib/dry/types/definition.rb

@@ -1,79 +0,0 @@
-require 'dry/types/builder'
-require 'dry/types/result'
-require 'dry/types/options'
-
-module Dry
-  module Types
-    class Definition
-      include Dry::Equalizer(:primitive, :options)
-      include Options
-      include Builder
-
-      attr_reader :options
-
-      attr_reader :primitive
-
-      def self.[](primitive)
-        if primitive == ::Array
-          Types::Array
-        elsif primitive == ::Hash
-          Types::Hash
-        else
-          self
-        end
-      end
-
-      def initialize(primitive, options = {})
-        super
-        @primitive = primitive
-        freeze
-      end
-
-      def name
-        primitive.name
-      end
-
-      def default?
-        false
-      end
-
-      def constrained?
-        false
-      end
-
-      def call(input)
-        input
-      end
-      alias_method :[], :call
-
-      def try(input, &block)
-        if valid?(input)
-          success(input)
-        else
-          failure = failure(input, "#{input.inspect} must be an instance of #{primitive}")
-          block ? yield(failure) : failure
-        end
-      end
-
-      def success(*args)
-        result(Result::Success, *args)
-      end
-
-      def failure(*args)
-        result(Result::Failure, *args)
-      end
-
-      def result(klass, *args)
-        klass.new(*args)
-      end
-
-      def primitive?(value)
-        value.is_a?(primitive)
-      end
-      alias_method :valid?, :primitive?
-    end
-  end
-end
-
-require 'dry/types/array'
-require 'dry/types/hash'

data/lib/dry/types/form.rb

@@ -1,53 +0,0 @@
-require 'dry/types/coercions/form'
-
-module Dry
-  module Types
-    register('form.nil') do
-      self['nil'].constructor(Coercions::Form.method(:to_nil))
-    end
-
-    register('form.date') do
-      self['date'].constructor(Coercions::Form.method(:to_date))
-    end
-
-    register('form.date_time') do
-      self['date_time'].constructor(Coercions::Form.method(:to_date_time))
-    end
-
-    register('form.time') do
-      self['time'].constructor(Coercions::Form.method(:to_time))
-    end
-
-    register('form.true') do
-      self['true'].constructor(Coercions::Form.method(:to_true))
-    end
-
-    register('form.false') do
-      self['false'].constructor(Coercions::Form.method(:to_false))
-    end
-
-    register('form.bool') do
-      (self['form.true'] | self['form.false']).safe
-    end
-
-    register('form.int') do
-      self['int'].constructor(Coercions::Form.method(:to_int))
-    end
-
-    register('form.float') do
-      self['float'].constructor(Coercions::Form.method(:to_float))
-    end
-
-    register('form.decimal') do
-      self['decimal'].constructor(Coercions::Form.method(:to_decimal))
-    end
-
-    register('form.array') do
-      self['array'].constructor(Coercions::Form.method(:to_ary)).safe
-    end
-
-    register('form.hash') do
-      self['hash'].constructor(Coercions::Form.method(:to_hash)).safe
-    end
-  end
-end

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

@@ -1,156 +0,0 @@
-module Dry
-  module Types
-    class Hash < Definition
-      class Schema < Hash
-        attr_reader :member_types
-
-        def initialize(_primitive, options)
-          @member_types = options.fetch(:member_types)
-          super
-        end
-
-        def call(hash)
-          coerce(hash)
-        end
-        alias_method :[], :call
-
-        def try(hash, &block)
-          success = true
-          output  = {}
-
-          begin
-            result = try_coerce(hash) do |key, member_result|
-              success &&= member_result.success?
-              output[key] = member_result.input
-
-              member_result
-            end
-          rescue ConstraintError, UnknownKeysError, SchemaError => e
-            success = false
-            result = e
-          end
-
-          if success
-            success(output)
-          else
-            failure = failure(output, result)
-            block ? yield(failure) : failure
-          end
-        end
-
-        private
-
-        def try_coerce(hash)
-          resolve(hash) do |type, key, value|
-            yield(key, type.try(value))
-          end
-        end
-
-        def coerce(hash)
-          resolve(hash) do |type, key, value|
-            begin
-              type.call(value)
-            rescue ConstraintError
-              raise SchemaError.new(key, value)
-            end
-          end
-        end
-
-        def resolve(hash)
-          member_types.each_with_object({}) do |(key, type), result|
-            if hash.key?(key)
-              result[key] = yield(type, key, hash[key])
-            else
-              resolve_missing_value(result, key, type)
-            end
-          end
-        end
-
-        def resolve_missing_value(result, key, type)
-          if type.default?
-            result[key] = type.evaluate
-          else
-            super
-          end
-        end
-      end
-
-      class Permissive < Schema
-        private
-
-        def resolve_missing_value(_, key, _)
-          raise MissingKeyError, key
-        end
-      end
-
-      class Strict < Permissive
-        private
-
-        def resolve(hash)
-          unexpected = hash.keys - member_types.keys
-          raise UnknownKeysError.new(*unexpected) unless unexpected.empty?
-
-          super do |member_type, key, value|
-            type = member_type.default? ? member_type.type : member_type
-
-            yield(type, key, value)
-          end
-        end
-      end
-
-      class StrictWithDefaults < Strict
-        private
-
-        def resolve_missing_value(result, key, type)
-          if type.default?
-            result[key] = type.value
-          else
-            super
-          end
-        end
-      end
-
-      class Weak < Schema
-        def self.new(primitive, options)
-          member_types = options.
-            fetch(:member_types).
-            each_with_object({}) { |(k, t), res| res[k] = t.safe }
-
-          super(primitive, options.merge(member_types: member_types))
-        end
-
-        def try(hash, &block)
-          if hash.instance_of?(::Hash)
-            super
-          else
-            result = failure(hash, "#{hash} must be a hash")
-            block ? yield(result) : result
-          end
-        end
-      end
-
-      class Symbolized < Weak
-        private
-
-        def resolve(hash)
-          member_types.each_with_object({}) do |(key, type), result|
-            keyname =
-              if hash.key?(key)
-                key
-              elsif hash.key?(string_key = key.to_s)
-                string_key
-              end
-
-            if keyname
-              result[key] = yield(type, key, hash[keyname])
-            else
-              resolve_missing_value(result, key, type)
-            end
-          end
-        end
-      end
-
-      private_constant(*constants(false))
-    end
-  end
-end

data/lib/spec/dry/types.rb

@@ -1,56 +0,0 @@
-RSpec.shared_examples_for 'Dry::Types::Definition without primitive' do
-  def be_boolean
-    satisfy { |x| x == true || x == false  }
-  end
-
-  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
-      expect(type.default?).to be_boolean
-    end
-  end
-
-  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
-      expect(type).to eql(type)
-    end
-  end
-
-  describe '#==' do
-    it 'has #== defined' do
-      expect(type).to eq(type)
-    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')
-
-      expect(with_meta).to be_instance_of(type.class)
-      expect(with_meta.meta).to eql(foo: :bar, baz: '1')
-    end
-  end
-end
-
-RSpec.shared_examples_for Dry::Types::Definition do
-  it_behaves_like 'Dry::Types::Definition without primitive'
-
-  describe '#primitive' do
-    it 'returns a class' do
-      expect(type.primitive).to be_instance_of(Class)
-    end
-  end
-end