dry-types 0.12.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8c05eebb29de4255fa90d96c51bc4050c76272d59ba3f71a992785fdaefcadf
-  data.tar.gz: f8c457dd897b0dceaa696751b787bc607f355553c53be88a94cd0f05f8e063ae
+  metadata.gz: a75136625920c87b6bc3a3086ce8e057b281e26dbde7ad783f00e905e68d4209
+  data.tar.gz: fb425d0891a89dd65f05527664edcaca3511a51627cc84f9872c2b01e3ffa585
 SHA512:
-  metadata.gz: bc10a547c544015cc3b384db0362df51f5a72520de44ea3594507f56a7513bb2e925061d3bf62e1e3d87bf85652f3df2ffec893ab6d30bc9c1ae7da7070e613c
-  data.tar.gz: 40cbc9bf37b49e0b1c8dd3738ef11a787ae2bf8a759c3511f17e9e8df17a834990fb1087fe53081f1f0e418fd685f25cc9a53023cd1f081c3cf243179ac5f5b9
+  metadata.gz: 893b870ed93db86a97184ff07873df4d58e3379b3a561e6f3962c2aa656c52e4cbe856d9f5f401da0d85da86b5a78880e1173a8c78fcbf4ff2c86b70417a9313
+  data.tar.gz: 05db55e6352c55dc2a8357f4062f0bef409babe4a7702ab1e8a6c4d3a1d12e90a7be7b0865bf197ce6ede56abeb0c59b22a580428b6cf10ade5148ee3c763a81

data/.travis.yml

@@ -3,15 +3,18 @@ dist: trusty
 sudo: required
 cache: bundler
 bundler_args: --without benchmarks tools
-after_success:
-  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 script:
   - bundle exec rake
+before_install:
+  - gem update --system
+after_success:
+  - '[ -d coverage ] && bundle exec codeclimate-test-reporter'
 rvm:
-  - 2.2.7
-  - 2.3.4
-  - 2.4.1
-  - jruby-9.1.10.0
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
+  - jruby-9.1.15.0
 env:
   global:
     - COVERAGE=true

data/CHANGELOG.md

@@ -1,10 +1,99 @@
-# v0.12.3 2018-06-12
+# v0.13.0 2018-03-03
+
+## Changed
+
+* [BREAKING] Renamed `Types::Form` to `Types::Params`. You can opt-in the former name with `require 'dry/types/compat/form_types'`. It will be dropped in the next release (ndrluis)
+* [BREAKING] The `Int` types was renamed to `Integer`, this was the only type named differently from the standard Ruby classes so it has been made consistent. The former name is available with `require 'dry/types/compat/int'` (GustavoCaso + flash-gordon)
+* [BREAKING] Default types are not evaluated on `nil`. Default values are evaluated _only_ if no value were given.
+  ```ruby
+    type = Types::Strict::String.default("hello")
+    type[nil] # => constraint error
+    type[] # => "hello"
+  ```
+  This change allowed to greatly simplify hash schemas, make them a lot more flexible yet predictable (see below).
+* [BREAKING] `Dry::Types.register_class` was removed, `Dry::Types.register` was made private API, do not register your types in the global `dry-types` container, use a module instead, e.g. `Types` (flash-gordon)
+* [BREAKING] Enum types don't accept value index anymore. Instead, explicit mapping is supported, see below (flash-gordon)
+
+
+## Added
+
+* Hash schemas were rewritten. The old API is still around but is going to be deprecated and removed before 1.0. The new API is simpler and more flexible. Instead of having a bunch of predefined schemas you can build your own by combining the following methods:
+
+  1. `Schema#with_key_transform`—transforms keys of input hashes, for things like symbolizing etc.
+  2. `Schema#strict`—makes a schema intolerant to unknown keys.
+  3. `Hash#with_type_transform`—transforms member types with an arbitrary block. For instance,
+
+    ```ruby
+    optional_keys = Types::Hash.with_type_transform { |t, _key| t.optional }
+    schema = optional_keys.schema(name: 'strict.string', age: 'strict.int')
+    schema.(name: "Jane", age: nil) # => {name: "Jane", age: nil}
+    ```
+
+  Note that by default all keys are required, if a key is expected to absent, add to the corresponding type's meta `omittable: true`:
+
+  ```ruby
+  intolerant = Types::Hash.schema(name: Types::Strict::String)
+  intolerant[{}] # => Dry::Types::MissingKeyError
+  tolerant = Types::Hash.schema(name: Types::Strict::String.meta(omittable: true))
+  tolerant[{}] # => {}
+  tolerant_with_default = Types::Hash.schema(name: Types::Strict::String.meta(omittable: true).default("John"))
+  tolerant[{}] # => {name: "John"}
+  ```
+
+  The new API is composable in a natural way:
+
+  ```ruby
+  TOLERANT = Types::Hash.with_type_transform { |t| t.meta(omittable: true) }.freeze
+  user = TOLERANT.schema(name: 'strict.string', age: 'strict.int')
+  user.(name: "Jane") # => {name: "Jane"}
+
+  TOLERANT_SYMBOLIZED = TOLERANT.with_key_transform(&:to_sym)
+  user_sym = TOLERANT_SYMBOLIZED.schema(name: 'strict.string', age: 'strict.int')
+  user_sym.("name" => "Jane") # => {name: "Jane"}
+  ```
+
+  (flash-gordon)
+
+* `Types.Strict` is an alias for `Types.Instance` (flash-gordon)
+  ```ruby
+  strict_range = Types.Strict(Range)
+  strict_range == Types.Instance(Range) # => true
+  ```
+* `Enum#include?` is an alias to `Enum#valud?` (d-Pixie + flash-gordon)
+* `Range` was added (GustavoCaso)
+* `Array` types filter out `Undefined` values, if you have an array type with a constructor type as its member, the constructor now can return `Dry::Types::Undefined` to indicate empty value:
+  ```ruby
+  filter_empty_strings = Types::Strict::Array.of(
+    Types::Strict::String.constructor { |input|
+      input.to_s.yield_self { |s| s.empty? ? Dry::Types::Undefined : s }
+    }
+  )
+  filter_empty_strings.(["John", nil, "", "Jane"]) # => ["John", "Jane"]
+  ```
+* `Types::Map` was added for homogeneous hashes, when only types of keys and values are known in advance, not specific key names (fledman + flash-gordon)
+  ```ruby
+    int_to_string = Types::Hash.map('strict.integer', 'strict.string')
+    int_to_string[0 => 'foo'] # => { 0 => "foo" }
+    int_to_string[0 => 1] # Dry::Types::MapError: input value 1 for key 0 is invalid: type?(String, 1)
+  ```
+* Enum supports mappings (bolshakov + flash-gordon)
+  ```ruby
+  dict = Types::Strict::String.enum('draft' => 0, 'published' => 10, 'archived' => 20)
+  dict['published'] # => 'published'
+  dict[10] # => 'published'
+  ```
 
 ## Fixed
 
-* Fixed `constrained?` for constructor types (solnic)
+* Fixed applying constraints to optional type, i.e. `.optional.constrained` works correctly (flash-gordon)
+* Fixed enum working with optionals (flash-gordon)
+
+## Internal
+
+* Dropped the `dry-configurable` dependency (GustavoCaso)
+* The gem now uses `dry-inflector` for inflections instead of `inflecto` (GustavoCaso)
 
-[Compare v0.12.2...v0.12.3](https://github.com/dry-rb/dry-types/compare/v0.12.2...v0.12.3)
+[Compare v0.12.2...v0.13.0](https://github.com/dry-rb/dry-types/compare/v0.12.2...v0.13.0)
 
 # v0.12.2 2017-11-04
 

data/CONTRIBUTING.md

@@ -10,7 +10,7 @@ Report a feature request **only after discussing it first on [discourse.dry-rb.o
 
 ## Reporting questions, support requests, ideas, concerns etc.
 
-**PLEASE DON'T** - use [discourse.dry-rb.org](http://discourse.dry-rb.org) instead.
+**PLEASE DON'T** - use [discourse.dry-rb.org](https://discourse.dry-rb.org) instead.
 
 # Pull Request Guidelines
 

data/Gemfile

@@ -22,5 +22,3 @@ group :benchmarks do
   gem 'attrio'
   gem 'dry-struct'
 end
-
-gem 'dry-logic', git: 'https://github.com/dry-rb/dry-logic'

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

@@ -28,12 +28,11 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.2.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_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 11.0"

data/lib/dry/types.rb

@@ -2,33 +2,35 @@ require 'bigdecimal'
 require 'date'
 require 'set'
 
-require 'inflecto'
 require 'concurrent'
 
 require 'dry-container'
 require 'dry-equalizer'
 require 'dry/core/extensions'
 require 'dry/core/constants'
+require 'dry/core/class_attributes'
 
 require 'dry/types/version'
 require 'dry/types/container'
+require 'dry/types/inflector'
 require 'dry/types/type'
 require 'dry/types/definition'
 require 'dry/types/constructor'
-require 'dry/types/fn_container'
 require 'dry/types/builder_methods'
 
 require 'dry/types/errors'
 
 module Dry
   module Types
-    extend Dry::Configurable
     extend Dry::Core::Extensions
+    extend Dry::Core::ClassAttributes
     include Dry::Core::Constants
 
     # @!attribute [r] namespace
     #   @return [Container{String => Definition}]
-    setting :namespace, self
+    defines :namespace
+
+    namespace self
 
     TYPE_SPEC_REGEX = %r[(.+)<(.+)>].freeze
 
@@ -46,7 +48,7 @@ module Dry
        ' do `include Dry::Types.module` in places where you want to have access'\
        ' to built-in types'
 
-      define_constants(config.namespace, type_keys)
+      define_constants(self.namespace, type_keys)
     end
 
     # @return [Container{String => Definition}]
@@ -63,19 +65,11 @@ module Dry
     # @param [Type] type
     # @param [#call,nil] block
     # @return [Container{String => Definition}]
+    # @api private
     def self.register(name, type = nil, &block)
       container.register(name, type || block.call)
     end
 
-    # Registers given +klass+ in {#container} using +meth+ constructor
-    # @param [Class] klass
-    # @param [Symbol] meth
-    # @return [Container{String => Definition}]
-    def self.register_class(klass, meth = :new)
-      type = Definition.new(klass).constructor(klass.method(meth))
-      container.register(identifier(klass), type)
-    end
-
     # @param [String,Class] name
     # @return [Type,Class]
     def self.[](name)
@@ -108,7 +102,7 @@ module Dry
     def self.define_constants(namespace, identifiers)
       names = identifiers.map do |id|
         parts = id.split('.')
-        [Inflecto.camelize(parts.pop), parts.map(&Inflecto.method(:camelize))]
+        [Inflector.camelize(parts.pop), parts.map(&Inflector.method(:camelize))]
       end
 
       names.map do |(klass, parts)|
@@ -123,7 +117,7 @@ module Dry
     # @param [#to_s] klass
     # @return [String]
     def self.identifier(klass)
-      Inflecto.underscore(klass).tr('/', '.')
+      Inflector.underscore(klass).tr('/', '.')
     end
 
     # @return [Concurrent::Map]
@@ -141,12 +135,12 @@ module Dry
 
     # @api private
     def self.const_missing(const)
-      underscored = Inflecto.underscore(const)
+      underscored = Inflector.underscore(const)
 
       if type_keys.any? { |key| key.split('.')[0] == underscored }
         raise NameError,
               'dry-types does not define constants for default types. '\
-              'You can access the predefined types with [], e.g. Dry::Types["strict.int"] '\
+              'You can access the predefined types with [], e.g. Dry::Types["strict.integer"] '\
               'or generate a module with types using Dry::Types.module'
       else
         super

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/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/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.rb

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

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 == 'params.integer'
+      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