dry-types 0.12.3 → 0.14.1

data/README.md

@@ -1,6 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-types
 [travis]: https://travis-ci.org/dry-rb/dry-types
-[gemnasium]: https://gemnasium.com/dry-rb/dry-types
 [codeclimate]: https://codeclimate.com/github/dry-rb/dry-types
 [coveralls]: https://coveralls.io/r/dry-rb/dry-types
 [inchpages]: http://inch-ci.org/github/dry-rb/dry-types
@@ -9,7 +8,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/dry-types.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-types.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/dry-rb/dry-types.svg)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/dry-rb/dry-types/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/dry-rb/dry-types/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-types.svg?branch=master)][inchpages]

data/Rakefile

@@ -4,11 +4,13 @@ require "rspec/core/rake_task"
 task :run_specs do
   require 'rspec/core'
 
-  RSpec::Core::Runner.run(['spec/dry'])
+  types_result = RSpec::Core::Runner.run(['spec/dry'])
   RSpec.clear_examples
 
   Dry::Types.load_extensions(:maybe)
-  RSpec::Core::Runner.run(['spec'])
+  ext_result = RSpec::Core::Runner.run(['spec'])
+
+  exit [types_result, ext_result].max
 end
 
 task default: :run_specs

data/benchmarks/hash_schemas.rb

@@ -7,8 +7,8 @@ module SchemaBench
   def self.hash_schema(type)
     Dry::Types['hash'].public_send(type,
       email:   Dry::Types['string'],
-      age:     Dry::Types['form.int'],
-      admin:   Dry::Types['form.bool'],
+      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']

data/dry-types.gemspec

@@ -17,6 +17,9 @@ Gem::Specification.new do |spec|
   # delete this section to allow pushing this gem to any host.
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['changelog_uri'] = "https://github.com/dry-rb/dry-types/blob/master/CHANGELOG.md"
+    spec.metadata['source_code_uri'] = "https://github.com/dry-rb/dry-types"
+    spec.metadata['bug_tracker_uri'] = "https://github.com/dry-rb/dry-types/issues"
   else
     raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
@@ -25,17 +28,16 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.2.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_runtime_dependency 'dry-core', '~> 0.2', '>= 0.2.1'
+  spec.add_runtime_dependency 'dry-core', '~> 0.4', '>= 0.4.4'
+  spec.add_runtime_dependency 'dry-inflector', '~> 0.1', '>= 0.1.2'
   spec.add_runtime_dependency 'dry-container', '~> 0.3'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
-  spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
-  spec.add_runtime_dependency 'dry-logic', '~> 0.4', '>= 0.4.2'
-  spec.add_runtime_dependency 'inflecto', '~> 0.0.0', '>= 0.0.2'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.5', '>= 0.5'
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 11.0"
   spec.add_development_dependency "rspec", "~> 3.3"
   spec.add_development_dependency 'dry-monads', '~> 0.2'

data/lib/dry/types/array/member.rb

@@ -34,7 +34,7 @@ module Dry
         # @return [Result,Logic::Result]
         def try(input, &block)
           if input.is_a?(::Array)
-            result = call(input, :try)
+            result = call(input, :try).reject { |r| r.input.equal?(Undefined) }
             output = result.map(&:input)
 
             if result.all?(&:success?)
@@ -53,7 +53,11 @@ module Dry
         #
         # @see Definition#to_ast
         def to_ast(meta: true)
-          [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+          if member.respond_to?(:to_ast)
+            [:array, [member.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+          else
+            [:array, [member, meta ? self.meta : EMPTY_HASH]]
+          end
         end
       end
     end

data/lib/dry/types/array.rb

@@ -11,14 +11,12 @@ module Dry
       def of(type)
         member =
           case type
-          when String, Class then Types[type]
+          when String then Types[type]
           else type
           end
 
         Array::Member.new(primitive, **options, member: member)
       end
-
-      deprecate :member, :of
     end
   end
 end

data/lib/dry/types/builder.rb

@@ -31,7 +31,7 @@ module Dry
       # @raise [ConstraintError]
       # @return [Default]
       def default(input = Undefined, &block)
-        value = input == Undefined ? block : input
+        value = input.equal?(Undefined) ? block : input
 
         if value.is_a?(Proc) || valid?(value)
           Default[value].new(self, value)
@@ -43,7 +43,14 @@ module Dry
       # @param [Array] values
       # @return [Enum]
       def enum(*values)
-        Enum.new(constrained(included_in: values), values: values)
+        mapping =
+          if values.length == 1 && values[0].is_a?(::Hash)
+            values[0]
+          else
+            ::Hash[values.zip(values)]
+          end
+
+        Enum.new(constrained(included_in: mapping.keys), mapping: mapping)
       end
 
       # @return [Safe]

data/lib/dry/types/builder_methods.rb

@@ -34,6 +34,11 @@ module Dry
       # Build a type which values are instances of a given class
       # Values are checked using `is_a?` call
       #
+      # @example
+      #   Types::Error = Types.Instance(StandardError)
+      #   Types::Error = Types.Strict(StandardError)
+      #   Types.Strict(Integer) == Types::Strict::Int # => true
+      #
       # @param [Class,Module] klass Class or module
       #
       # @return [Dry::Types::Type]
@@ -41,6 +46,7 @@ module Dry
       def Instance(klass)
         Definition.new(klass).constrained(type: klass)
       end
+      alias_method :Strict, :Instance
 
       # Build a type with a single value
       # The equality check done with `eql?`
@@ -77,7 +83,7 @@ module Dry
         Definition.new(klass).constructor(cons || block || klass.method(:new))
       end
 
-      # Build a definiton type
+      # Build a definition type
       #
       # @param [Class] klass
       #
@@ -86,6 +92,21 @@ module Dry
       def Definition(klass)
         Definition.new(klass)
       end
+
+      # Build a map type
+      #
+      # @example
+      #   Types::IntMap = Types.Map(Types::Strict::Integer, 'any')
+      #   Types::IntStringMap = Types.Map(Types::Strict::Integer, Types::Strict::String)
+      #
+      # @param [Type] key_type Key type
+      # @param [Type] value_type Value type
+      #
+      # @return [Dry::Types::Map]
+      # @api public
+      def Map(key_type, value_type)
+        Types['hash'].map(key_type, value_type)
+      end
     end
   end
 end

data/lib/dry/types/coercions/{form.rb → params.rb}

@@ -4,7 +4,7 @@ require 'bigdecimal/util'
 module Dry
   module Types
     module Coercions
-      module Form
+      module Params
         TRUE_VALUES = %w[1 on On ON t true True TRUE T y yes Yes YES Y].freeze
         FALSE_VALUES = %w[0 off Off OFF f false False FALSE F n no No NO N].freeze
         BOOLEAN_MAP = ::Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,14 @@
+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/compat.rb

@@ -0,0 +1,2 @@
+require 'dry/types/compat/int'
+require 'dry/types/compat/form_types'

data/lib/dry/types/compiler.rb

@@ -54,7 +54,8 @@ module Dry
 
       def visit_array(node)
         member, meta = node
-        registry['array'].of(visit(member)).meta(meta)
+        member = member.is_a?(Class) ? member : visit(member)
+        registry['array'].of(member).meta(meta)
       end
 
       def visit_hash(node)
@@ -62,6 +63,11 @@ module Dry
         merge_with('hash', constructor, schema).meta(meta)
       end
 
+      def visit_hash_schema(node)
+        schema, meta = node
+        merge_with_schema('hash', schema).meta(meta)
+      end
+
       def visit_json_hash(node)
         schema, meta = node
         merge_with('json.hash', :symbolized, schema).meta(meta)
@@ -72,14 +78,14 @@ module Dry
         registry['json.array'].of(visit(member)).meta(meta)
       end
 
-      def visit_form_hash(node)
+      def visit_params_hash(node)
         schema, meta = node
-        merge_with('form.hash', :symbolized, schema).meta(meta)
+        merge_with('params.hash', :symbolized, schema).meta(meta)
       end
 
-      def visit_form_array(node)
+      def visit_params_array(node)
         member, meta = node
-        registry['form.array'].of(visit(member)).meta(meta)
+        registry['params.array'].of(visit(member)).meta(meta)
       end
 
       def visit_member(node)
@@ -87,9 +93,26 @@ module Dry
         { name => visit(type) }
       end
 
+      def visit_enum(node)
+        type, mapping, meta = node
+        Enum.new(visit(type), mapping: mapping, meta: meta)
+      end
+
+      def visit_map(node)
+        key_type, value_type, meta = node
+        registry['hash'].map(visit(key_type), visit(value_type)).meta(meta)
+      end
+
       def merge_with(hash_id, constructor, schema)
-        registry[hash_id].__send__(
-          constructor, schema.map { |key| visit(key) }.reduce({}, :update)
+        registry[hash_id].schema(
+          schema.map { |key| visit(key) }.reduce({}, :update),
+          constructor
+        )
+      end
+
+      def merge_with_schema(hash_id, schema)
+        registry[hash_id].instantiate(
+          schema.map { |key| visit(key) }.reduce({}, :update)
         )
       end
     end

data/lib/dry/types/constructor.rb

@@ -1,4 +1,4 @@
-require 'dry/types/decorator'
+require 'dry/types/fn_container'
 
 module Dry
   module Types
@@ -16,15 +16,15 @@ module Dry
       # @param [Builder, Object] input
       # @param [Hash] options
       # @param [#call, nil] block
-      def self.new(input, options = {}, &block)
+      def self.new(input, **options, &block)
         type = input.is_a?(Builder) ? input : Definition.new(input)
-        super(type, options, &block)
+        super(type, **options, &block)
       end
 
       # @param [Type] type
       # @param [Hash] options
       # @param [#call, nil] block
-      def initialize(type, options = {}, &block)
+      def initialize(type, **options, &block)
         @type = type
         @fn = options.fetch(:fn, block)
 
@@ -43,6 +43,10 @@ module Dry
         type.name
       end
 
+      def default?
+        type.default?
+      end
+
       # @param [Object] input
       # @return [Object]
       def call(input)
@@ -74,7 +78,11 @@ module Dry
       # @param [Object] value
       # @return [Boolean]
       def valid?(value)
-        super && type.valid?(value)
+        constructed_value = fn[value]
+      rescue NoMethodError, TypeError, ArgumentError
+        false
+      else
+        type.valid?(constructed_value)
       end
       alias_method :===, :valid?
 

data/lib/dry/types/core.rb

@@ -4,7 +4,7 @@ module Dry
   module Types
     COERCIBLE = {
       string: String,
-      int: Integer,
+      integer: Integer,
       float: Float,
       decimal: BigDecimal,
       array: ::Array,
@@ -19,7 +19,8 @@ module Dry
       false: FalseClass,
       date: Date,
       date_time: DateTime,
-      time: Time
+      time: Time,
+      range: Range
     }.freeze
 
     ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
@@ -61,5 +62,5 @@ module Dry
 end
 
 require 'dry/types/coercions'
-require 'dry/types/form'
+require 'dry/types/params'
 require 'dry/types/json'

data/lib/dry/types/decorator.rb

@@ -39,6 +39,11 @@ module Dry
         type.constrained?
       end
 
+      # @return [Sum]
+      def optional
+        Types['strict.nil'] | self
+      end
+
       # @param [Symbol] meth
       # @param [Boolean] include_private
       # @return [Boolean]
@@ -63,7 +68,7 @@ module Dry
           response = type.__send__(meth, *args, &block)
 
           if decorate?(response)
-            self.class.new(response, options)
+            __new__(response)
           else
             response
           end
@@ -71,6 +76,11 @@ module Dry
           super
         end
       end
+
+      # Replace underlying type
+      def __new__(type)
+        self.class.new(type, options)
+      end
     end
   end
 end

data/lib/dry/types/default.rb

@@ -35,7 +35,7 @@ module Dry
 
       # @param [Type] type
       # @param [Object] value
-      def initialize(type, value, *)
+      def initialize(type, value, **options)
         super
         @value = value
       end
@@ -57,10 +57,14 @@ module Dry
         success(call(input))
       end
 
+      def valid?(value = Undefined)
+        value.equal?(Undefined) || super
+      end
+
       # @param [Object] input
       # @return [Object] value passed through {#type} or {#default} value
-      def call(input)
-        if input.nil?
+      def call(input = Undefined)
+        if input.equal?(Undefined)
           evaluate
         else
           output = type[input]
@@ -68,6 +72,13 @@ module Dry
         end
       end
       alias_method :[], :call
+
+      private
+
+      # Replace underlying type
+      def __new__(type)
+        self.class.new(type, value, options)
+      end
     end
   end
 end

data/lib/dry/types/definition.rb

@@ -6,12 +6,9 @@ module Dry
   module Types
     class Definition
       include Type
-      include Dry::Equalizer(:primitive, :options, :meta)
       include Options
       include Builder
-
-      # @return [Hash]
-      attr_reader :options
+      include Dry::Equalizer(:primitive, :options, :meta)
 
       # @return [Class]
       attr_reader :primitive
@@ -30,7 +27,7 @@ module Dry
 
       # @param [Type,Class] primitive
       # @param [Hash] options
-      def initialize(primitive, options = {})
+      def initialize(primitive, **options)
         super
         @primitive = primitive
         freeze
@@ -84,20 +81,12 @@ module Dry
         Result::Success.new(input)
       end
 
-
       # @param (see Failure#initialize)
       # @return [Result::Failure]
       def failure(input, error)
         Result::Failure.new(input, error)
       end
 
-      # @param [Object] klass class of the result instance
-      # @param [Array] args arguments for the +klass#initialize+ method
-      # @return [Object] new instance of the given +klass+
-      def result(klass, *args)
-        klass.new(*args)
-      end
-
       # Checks whether value is of a #primitive class
       # @param [Object] value
       # @return [Boolean]
@@ -121,3 +110,4 @@ end
 
 require 'dry/types/array'
 require 'dry/types/hash'
+require 'dry/types/map'

data/lib/dry/types/enum.rb

@@ -4,7 +4,7 @@ module Dry
   module Types
     class Enum
       include Type
-      include Dry::Equalizer(:type, :options, :values)
+      include Dry::Equalizer(:type, :options, :mapping)
       include Decorator
 
       # @return [Array]
@@ -13,40 +13,68 @@ module Dry
       # @return [Hash]
       attr_reader :mapping
 
+      # @return [Hash]
+      attr_reader :inverted_mapping
+
       # @param [Type] type
       # @param [Hash] options
       # @option options [Array] :values
       def initialize(type, options)
         super
-        @values = options.fetch(:values).freeze
-        @values.each(&:freeze)
-        @mapping = values.each_with_object({}) { |v, h| h[values.index(v)] = v }.freeze
+        @mapping = options.fetch(:mapping).freeze
+        @values = @mapping.keys.freeze
+        @inverted_mapping = @mapping.invert.freeze
+        freeze
       end
 
       # @param [Object] input
       # @return [Object]
-      def call(input)
-        value =
-          if values.include?(input)
-            input
-          elsif mapping.key?(input)
-            mapping[input]
-          end
-
-        type[value || input]
+      def call(input = Undefined)
+        type[map_value(input)]
       end
       alias_method :[], :call
 
+      # @param [Object] input
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      # @return [Logic::Result]
+      # @return [Object] if coercion fails and a block is given
+      def try(input)
+        super(map_value(input))
+      end
+
       def default(*)
         raise '.enum(*values).default(value) is not supported. Call '\
               '.default(value).enum(*values) instead'
       end
 
+      # Check whether a value is in the enum
+      alias_method :include?, :valid?
+
       # @api public
       #
       # @see Definition#to_ast
       def to_ast(meta: true)
-        [:enum, [type.to_ast(meta: meta), meta ? self.meta : EMPTY_HASH]]
+        [:enum, [type.to_ast(meta: meta),
+                 mapping,
+                 meta ? self.meta : EMPTY_HASH]]
+      end
+
+      private
+
+      # Maps a value
+      #
+      # @params [Object]
+      # @return [Object]
+      # @api private
+      def map_value(input)
+        if input.equal?(Undefined)
+          type.call
+        elsif mapping.key?(input)
+          input
+        else
+          inverted_mapping.fetch(input, input)
+        end
       end
     end
   end

data/lib/dry/types/errors.rb

@@ -1,10 +1,12 @@
 module Dry
   module Types
-    extend Dry::Configurable
+    extend Dry::Core::ClassAttributes
 
     # @!attribute [r] namespace
     #   @return [Container{String => Definition}]
-    setting :namespace, self
+    defines :namespace
+
+    namespace self
 
     class SchemaError < TypeError
       # @param [String,Symbol] key
@@ -15,6 +17,8 @@ module Dry
       end
     end
 
+    MapError = Class.new(TypeError)
+
     SchemaKeyError = Class.new(KeyError)
     private_constant(:SchemaKeyError)