dry-types 0.13.2 → 1.5.1

data/CONTRIBUTING.md

@@ -1,29 +0,0 @@
-# Issue Guidelines
-
-## Reporting bugs
-
-If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
-
-## Reporting feature requests
-
-Report a feature request **only after discussing it first on [discourse.dry-rb.org](https://discourse.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
-
-## Reporting questions, support requests, ideas, concerns etc.
-
-**PLEASE DON'T** - use [discourse.dry-rb.org](https://discourse.dry-rb.org) instead.
-
-# Pull Request Guidelines
-
-A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
-
-Other requirements:
-
-1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
-2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
-3) Add API documentation if it's a new feature
-4) Update API documentation if it changes an existing feature
-5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
-
-# Asking for help
-
-If these guidelines aren't helpful, and you're stuck, please post a message on [discourse.dry-rb.org](https://discourse.dry-rb.org).

data/Gemfile

@@ -1,24 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :test do
-  platform :mri do
-    gem "codeclimate-test-reporter", require: false
-    gem 'simplecov', require: false
-  end
-end
-
-group :tools do
-  gem 'pry-byebug', platform: :mri
-  gem 'mutant'
-  gem 'mutant-rspec'
-end
-
-group :benchmarks do
-  gem 'benchmark-ips'
-  gem 'virtus'
-  gem 'fast_attributes'
-  gem 'attrio'
-  gem 'dry-struct'
-end

data/Rakefile

@@ -1,20 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-task :run_specs do
-  require 'rspec/core'
-
-  types_result = RSpec::Core::Runner.run(['spec/dry'])
-  RSpec.clear_examples
-
-  Dry::Types.load_extensions(:maybe)
-  ext_result = RSpec::Core::Runner.run(['spec'])
-
-  exit [types_result, ext_result].max
-end
-
-task default: :run_specs
-
-require 'yard'
-require 'yard/rake/yardoc_task'
-YARD::Rake::YardocTask.new(:doc)

data/benchmarks/hash_schemas.rb

@@ -1,51 +0,0 @@
-$LOAD_PATH.unshift('lib')
-
-require 'bundler/setup'
-require 'dry-types'
-
-module SchemaBench
-  def self.hash_schema(type)
-    Dry::Types['hash'].public_send(type,
-      email:   Dry::Types['string'],
-      age:     Dry::Types['params.integer'],
-      admin:   Dry::Types['params.bool'],
-      address: Dry::Types['hash'].public_send(type,
-        city: Dry::Types['string'],
-        street: Dry::Types['string']
-      )
-    )
-  end
-
-  private_class_method(:hash_schema)
-
-  SCHEMAS =
-    Dry::Types::Hash
-      .public_instance_methods(false)
-      .map { |schema_type| [schema_type, hash_schema(schema_type)] }
-      .to_h
-
-  INPUT = {
-    email: 'jane@doe.org',
-    age: '20',
-    admin: '1',
-    address: { city: 'NYC', street: 'Street 1/2' }
-  }
-end
-
-require 'benchmark/ips'
-
-Benchmark.ips do |x|
-  SchemaBench::SCHEMAS.each do |schema_type, schema|
-    x.report("#{schema_type}#call") do
-      schema.call(SchemaBench::INPUT)
-    end
-  end
-
-  SchemaBench::SCHEMAS.each do |schema_type, schema|
-    x.report("#{schema_type}#try") do
-      schema.try(SchemaBench::INPUT)
-    end
-  end
-
-  x.compare!
-end

data/lib/dry/types/compat/form_types.rb

@@ -1,27 +0,0 @@
-require 'dry/core/deprecations'
-
-Dry::Core::Deprecations.warn('Form types were renamed to Params', tag: :'dry-types')
-
-module Dry
-  module Types
-    container.keys.grep(/^params\./).each do |key|
-      next if key.start_with?('params.int')
-      register(key.sub('params.', 'form.'), container[key])
-    end
-
-    register('form.int', self['params.integer'])
-    register('form.integer', self['params.integer'])
-
-    class Compiler
-      def visit_form_hash(node)
-        schema, meta = node
-        merge_with('params.hash', :symbolized, schema).meta(meta)
-      end
-
-      def visit_form_array(node)
-        member, meta = node
-        registry['params.array'].of(visit(member)).meta(meta)
-      end
-    end
-  end
-end

data/lib/dry/types/compat/int.rb

@@ -1,14 +0,0 @@
-require 'dry/core/deprecations'
-
-Dry::Core::Deprecations.warn('Int type was renamed to Integer', tag: :'dry-types')
-
-module Dry
-  module Types
-    register('int', self['integer'])
-    register('strict.int', self['strict.integer'])
-    register('coercible.int', self['coercible.integer'])
-    register('optional.strict.int', self['optional.strict.integer'])
-    register('optional.coercible.int', self['optional.coercible.integer'])
-    register('params.int', self['params.integer'])
-  end
-end

data/lib/dry/types/definition.rb

@@ -1,113 +0,0 @@
-require 'dry/types/builder'
-require 'dry/types/result'
-require 'dry/types/options'
-
-module Dry
-  module Types
-    class Definition
-      include Type
-      include Options
-      include Builder
-      include Dry::Equalizer(:primitive, :options, :meta)
-
-      # @return [Class]
-      attr_reader :primitive
-
-      # @param [Class] primitive
-      # @return [Type]
-      def self.[](primitive)
-        if primitive == ::Array
-          Types::Array
-        elsif primitive == ::Hash
-          Types::Hash
-        else
-          self
-        end
-      end
-
-      # @param [Type,Class] primitive
-      # @param [Hash] options
-      def initialize(primitive, options = {})
-        super
-        @primitive = primitive
-        freeze
-      end
-
-      # @return [String]
-      def name
-        primitive.name
-      end
-
-      # @return [false]
-      def default?
-        false
-      end
-
-      # @return [false]
-      def constrained?
-        false
-      end
-
-      # @return [false]
-      def optional?
-        false
-      end
-
-      # @param [BasicObject] input
-      # @return [BasicObject]
-      def call(input)
-        input
-      end
-      alias_method :[], :call
-
-      # @param [Object] input
-      # @param [#call,nil] block
-      # @yieldparam [Failure] failure
-      # @yieldreturn [Result]
-      # @return [Result,Logic::Result] when a block is not provided
-      # @return [nil] otherwise
-      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
-
-      # @param (see Dry::Types::Success#initialize)
-      # @return [Result::Success]
-      def success(input)
-        Result::Success.new(input)
-      end
-
-      # @param (see Failure#initialize)
-      # @return [Result::Failure]
-      def failure(input, error)
-        Result::Failure.new(input, error)
-      end
-
-      # Checks whether value is of a #primitive class
-      # @param [Object] value
-      # @return [Boolean]
-      def primitive?(value)
-        value.is_a?(primitive)
-      end
-      alias_method :valid?, :primitive?
-      alias_method :===, :primitive?
-
-      # Return AST representation of a type definition
-      #
-      # @api public
-      #
-      # @return [Array]
-      def to_ast(meta: true)
-        [:definition, [primitive, meta ? self.meta : EMPTY_HASH]]
-      end
-    end
-  end
-end
-
-require 'dry/types/array'
-require 'dry/types/hash'
-require 'dry/types/map'

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

@@ -1,199 +0,0 @@
-require 'dry/types/fn_container'
-
-module Dry
-  module Types
-    class Hash < Definition
-      # The built-in Hash type has constructors that you can use to define
-      # hashes with explicit schemas and coercible values using the built-in types.
-      #
-      # Basic {Schema} evaluates default values for keys missing in input hash
-      # (see {Schema#resolve_missing_value})
-      #
-      # @see Dry::Types::Default#evaluate
-      # @see Dry::Types::Default::Callable#evaluate
-      class Schema < Hash
-        NO_TRANSFORM = Dry::Types::FnContainer.register { |x| x }
-        SYMBOLIZE_KEY = Dry::Types::FnContainer.register(:to_sym.to_proc)
-
-        # @return [Hash{Symbol => Definition}]
-        attr_reader :member_types
-
-        # @return [#call]
-        attr_reader :transform_key
-
-        # @param [Class] _primitive
-        # @param [Hash] options
-        # @option options [Hash{Symbol => Definition}] :member_types
-        # @option options [String] :key_transform_fn
-        def initialize(_primitive, options)
-          @member_types = options.fetch(:member_types)
-
-          meta = options[:meta] || EMPTY_HASH
-          key_fn = meta.fetch(:key_transform_fn, NO_TRANSFORM)
-
-          @transform_key = Dry::Types::FnContainer[key_fn]
-
-          super
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def call(hash)
-          coerce(hash)
-        end
-        alias_method :[], :call
-
-        # @param [Hash] hash
-        # @yieldparam [Failure] failure
-        # @yieldreturn [Result]
-        # @return [Logic::Result]
-        # @return [Object] if coercion fails and a block is given
-        def try(hash)
-          if hash.is_a?(::Hash)
-            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
-          else
-            success = false
-            output = hash
-            result = "#{hash} must be a hash"
-          end
-
-          if success
-            success(output)
-          else
-            failure = failure(output, result)
-            block_given? ? yield(failure) : failure
-          end
-        end
-
-        # @param meta [Boolean] Whether to dump the meta to the AST
-        # @return [Array] An AST representation
-        def to_ast(meta: true)
-          [
-            :hash_schema,
-            [
-              member_types.map { |name, member| [:member, [name, member.to_ast(meta: meta)]] },
-              meta ? self.meta : EMPTY_HASH
-            ]
-          ]
-        end
-
-        # @param [Hash] hash
-        # @return [Boolean]
-        def valid?(hash)
-          result = try(hash)
-          result.success?
-        end
-        alias_method :===, :valid?
-
-        # Whether the schema rejects unknown keys
-        # @return [Boolean]
-        def strict?
-          meta.fetch(:strict, false)
-        end
-
-        # Make the schema intolerant to unknown keys
-        # @return [Schema]
-        def strict
-          meta(strict: true)
-        end
-
-        # Injects a key transformation function
-        # @param [#call,nil] proc
-        # @param [#call,nil] block
-        # @return [Schema]
-        def with_key_transform(proc = nil, &block)
-          fn = proc || block
-
-          if fn.nil?
-            raise ArgumentError, "a block or callable argument is required"
-          end
-
-          handle = Dry::Types::FnContainer.register(fn)
-          meta(key_transform_fn: handle)
-        end
-
-        # @param [{Symbol => Definition}] type_map
-        # @return [Schema]
-        def schema(type_map)
-          member_types = self.member_types.merge(transform_types(type_map))
-          Schema.new(primitive, **options, member_types: member_types, meta: meta)
-        end
-
-        private
-
-        def resolve(hash)
-          result = {}
-
-          hash.each do |key, value|
-            k = transform_key.(key)
-
-            if member_types.key?(k)
-              result[k] = yield(member_types[k], k, value)
-            elsif strict?
-              raise UnknownKeysError.new(*unexpected_keys(hash.keys))
-            end
-          end
-
-          if result.size < member_types.size
-            resolve_missing_keys(result, &Proc.new)
-          end
-
-          result
-        end
-
-        def resolve_missing_keys(result)
-          member_types.each do |k, type|
-            next if result.key?(k)
-
-            if type.default?
-              result[k] = yield(type, k, Undefined)
-            elsif !type.meta[:omittable]
-              raise MissingKeyError, k
-            end
-          end
-        end
-
-        # @param keys [Array<Symbol>]
-        # @return [Array<Symbol>]
-        def unexpected_keys(keys)
-          keys.map(&transform_key) - member_types.keys
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def try_coerce(hash)
-          resolve(hash) do |type, key, value|
-            yield(key, type.try(value))
-          end
-        end
-
-        # @param [Hash] hash
-        # @return [Hash{Symbol => Object}]
-        def coerce(hash)
-          resolve(hash) do |type, key, value|
-            begin
-              type.call(value)
-            rescue ConstraintError => e
-              raise SchemaError.new(key, value, e.result)
-            rescue TypeError, ArgumentError => e
-              raise SchemaError.new(key, value, e.message)
-            end
-          end
-        end
-      end
-    end
-  end
-end