dry-types 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f4827f984803481533626b7ebe6e51fe6b5cf5da3691a7e0f9681c4d321bd1a
-  data.tar.gz: 755af2027b59115fd97e1051bdea5eb400ca1a76cf39b19953538e4fb5bb28dc
+  metadata.gz: 87e78ecf331ef9c4d95759bf28c2694e413df18fd0397d3c3c51380320328417
+  data.tar.gz: ca84bf0a23d37d7f0beda024d573852d2a0701a76f54dee2255166981bd716c5
 SHA512:
-  metadata.gz: 18aa4a59b9fbe19721d65c57ca91f29b4f3935298e5947182953b9ffe92c7213fe4f209e55d3472a86d3d4645e8e0ccd200e5456af492026570b0f28f9255973
-  data.tar.gz: e9b2886e43868b544ec1e4cb9c30949bbd3bec9dba1089dcd08c7ba36e456458a8746ea2537d5241c63322b38505ddc86fecda4035ab0f545e675cbc4188ba15
+  metadata.gz: 8ae0d71644bfc391ada28229a68010a378b07e252c6ea5fdc27327065cdfc980b27a25bd9d63068966803a800a262958ef4ea0fc0296d4e865534e3fb3458dc8
+  data.tar.gz: a1e899fb498a414f3920f9a19bc8ca22fc4db2bf7e6063a7baca389c528c0fb4d9114522d57606d7143c872b6847b9f1134f04326d1dc5ba694853a0c3977390

data/.github/ISSUE_TEMPLATE/----please-don-t-ask-for-support-via-issues.md

@@ -0,0 +1,10 @@
+---
+name: "⚠️  Please don't ask for support via issues"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+

data/.github/ISSUE_TEMPLATE/---bug-report.md

@@ -0,0 +1,34 @@
+---
+name: "\U0001F41B Bug report"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Before you submit this: WE ONLY ACCEPT BUG REPORTS AND FEATURE REQUESTS**
+
+For more information see [our contribution guidelines](https://github.com/rom-rb/rom/blob/master/CONTRIBUTING.md)
+
+**Before you report**
+
+:warning: If you have a problem related to a schema, please **report it under [dry-schema issues](https://github.com/dry-rb/dry-schema/issues/new?assignees=&labels=bug&template=---bug-report.md&title=)** instead.
+
+**Describe the bug**
+
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+
+Provide detailed steps to reproduce, an executable script would be best.
+
+**Expected behavior**
+
+A clear and concise description of what you expected to happen.
+
+**Your environment**
+
+- Affects my production application: **YES/NO**
+- Ruby version: ...
+- OS: ...

data/.github/ISSUE_TEMPLATE/---feature-request.md

@@ -0,0 +1,18 @@
+---
+name: "\U0001F6E0 Feature request"
+about: See CONTRIBUTING.md for more information
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+Summary of what the feature is supposed to do.
+
+## Examples
+
+Code examples showing how the feature could be used.
+
+## Resources
+
+Additional information, like a link to the discussion forum thread where the feature was discussed etc.

data/.travis.yml

@@ -10,13 +10,19 @@ after_script:
 script:
   - bundle exec rake
 rvm:
-  - 2.6.3
-  - 2.5.5
-  - 2.4.6
-  - jruby-9.2.7.0
+  - 2.6.5
+  - 2.5.7
+  - 2.4.9
+  - ruby-head
 env:
   global:
     - COVERAGE=true
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+  include:
+    - rvm: jruby-9.2.8.0
+      jdk: openjdk8
 notifications:
   email: false
   webhooks:

data/CHANGELOG.md

@@ -1,3 +1,63 @@
+# 1.2.0 2019-10-06
+
+## Changed
+
+- `Dry::Types.[]` used to work with classes, now it's deprecated (flash-gordon)
+
+## Fixed
+
+- Bug with using a `Bool`-named struct as a schema key (flash-gordon)
+- A bunch of issues related to using `meta` on complex types (flash-gordon)
+- `Types.Constructor(...)` returns a `Types::Array` as it should (flash-gordon)
+
+## Added
+
+- `Optional::Params` types that coerce empty strings to `nil` (flash-gordon)
+  ```ruby
+  Dry::Types['optional.params.integer'].('') # => nil
+  Dry::Types['optional.params.integer'].('140') # => 140
+  Dry::Types['optional.params.integer'].('asd') # => exception!
+  ```
+  Keep in mind, Dry::Types['optional.params.integer'] and Dry::Types['params.integer'].optional are not the same, the latter doesn't handle empty strings.
+- Predicate inferrer was ported from dry-schema (authored by solnic)
+  ```ruby
+  require 'dry/types/predicate_inferrer'
+  Dry::Types::PredicateInferrer.new[Types::String]
+  # => [:str?]
+  Dry::Types::PredicateInferrer.new[Types::String | Types::Integer]
+  # => [[[:str?], [:int?]]]
+  ```
+  Note that the API of the predicate inferrer can change in the stable version, it's dictated by the needs of dry-schema so it should be considered as semi-stable. If you depend on it, write specs covering the desired behavior. Another option is copy-and-paste the whole thing to your project.
+- Primitive inferrer was ported from dry-schema (authored by solnic)
+  ```ruby
+  require 'dry/types/primitive_inferrer'
+  Dry::Types::PrimitiveInferrer.new[Types::String]
+  # => [String]
+  Dry::Types::PrimitiveInferrer.new[Types::String | Types::Integer]
+  # => [String, Integer]
+  Dry::Types::PrimitiveInferrer.new[Types::String.optional]
+  # => [NilClass, String]
+  ```
+  The primitive inferrer should be stable by now, you can rely on it.
+- The `monads` extension adds `Dry::Types::Result#to_monad`. This makes it compatible with do notation from dry-monads. Load it with `Dry::Types.load_extensions(:monads)` (skryukov)
+
+  ```ruby
+  Types = Dry.Types
+  Dry::Types.load_extensions(:monads)
+
+  class AddTen
+    include Dry::Monads[:result, :do]
+
+    def call(input)
+      integer = yield Types::Coercible::Integer.try(input)
+
+      Success(integer + 10)
+    end
+  end
+  ```
+
+[Compare v1.1.1...v1.2.0](https://github.com/dry-rb/dry-types/compare/v1.1.1...v1.2.0)
+
 # 1.1.1 2019-07-26
 
 ## Fixed

data/Gemfile

@@ -18,10 +18,12 @@ group :tools do
 end
 
 group :benchmarks do
-  gem 'attrio'
-  gem 'benchmark-ips'
-  gem 'dry-struct'
-  gem 'fast_attributes'
-  gem 'hotch'
-  gem 'virtus'
+  platform :mri do
+    gem 'attrio'
+    gem 'benchmark-ips'
+    gem 'dry-struct'
+    gem 'fast_attributes'
+    gem 'hotch'
+    gem 'virtus'
+  end
 end

data/docsite/source/array-with-member.html.md

@@ -0,0 +1,13 @@
+---
+title: Array With Member
+layout: gem-single
+name: dry-types
+---
+
+The built-in array type supports defining the member's type:
+
+``` ruby
+PostStatuses = Types::Array.of(Types::Coercible::String)
+
+PostStatuses[[:foo, :bar]] # ["foo", "bar"]
+```

data/docsite/source/built-in-types.html.md

@@ -0,0 +1,116 @@
+---
+title: Built-in Types
+layout: gem-single
+name: dry-types
+---
+
+Built-in types are grouped under 6 categories:
+
+- `nominal` - base type definitions with a primitive class and options
+- `strict` - constrained types with a primitive type check applied to input
+- `coercible` - types with constructors using kernel coercions
+- `params` - types with constructors performing non-strict coercions specific to HTTP parameters
+- `json` - types with constructors performing non-strict coercions specific to JSON
+- `maybe` - types accepting either nil or a specific primitive type
+
+### Categories
+
+Assuming you included `Dry::Types` ([see instructions](/gems/dry-types/1.0/getting-started)) in a module called `Types`:
+
+* Nominal types:
+  - `Types::Nominal::Any`
+  - `Types::Nominal::Nil`
+  - `Types::Nominal::Symbol`
+  - `Types::Nominal::Class`
+  - `Types::Nominal::True`
+  - `Types::Nominal::False`
+  - `Types::Nominal::Bool`
+  - `Types::Nominal::Integer`
+  - `Types::Nominal::Float`
+  - `Types::Nominal::Decimal`
+  - `Types::Nominal::String`
+  - `Types::Nominal::Date`
+  - `Types::Nominal::DateTime`
+  - `Types::Nominal::Time`
+  - `Types::Nominal::Array`
+  - `Types::Nominal::Hash`
+
+* `Strict` types will raise an error if passed a value of the wrong type:
+  - `Types::Strict::Nil`
+  - `Types::Strict::Symbol`
+  - `Types::Strict::Class`
+  - `Types::Strict::True`
+  - `Types::Strict::False`
+  - `Types::Strict::Bool`
+  - `Types::Strict::Integer`
+  - `Types::Strict::Float`
+  - `Types::Strict::Decimal`
+  - `Types::Strict::String`
+  - `Types::Strict::Date`
+  - `Types::Strict::DateTime`
+  - `Types::Strict::Time`
+  - `Types::Strict::Array`
+  - `Types::Strict::Hash`
+
+> All types in the `strict` category are [constrained](/gems/dry-types/1.0/constraints) by a type-check that is applied to make sure that the input is an instance of the primitive:
+
+``` ruby
+Types::Strict::Integer[1] # => 1
+Types::Strict::Integer['1'] # => raises Dry::Types::ConstraintError
+```
+
+* `Coercible` types will attempt to cast values to the correct class using kernel coercion methods:
+  - `Types::Coercible::String`
+  - `Types::Coercible::Integer`
+  - `Types::Coercible::Float`
+  - `Types::Coercible::Decimal`
+  - `Types::Coercible::Array`
+  - `Types::Coercible::Hash`
+
+* Types suitable for `Params` param processing with coercions:
+  - `Types::Params::Nil`
+  - `Types::Params::Date`
+  - `Types::Params::DateTime`
+  - `Types::Params::Time`
+  - `Types::Params::True`
+  - `Types::Params::False`
+  - `Types::Params::Bool`
+  - `Types::Params::Integer`
+  - `Types::Params::Float`
+  - `Types::Params::Decimal`
+  - `Types::Params::Array`
+  - `Types::Params::Hash`
+
+* Types suitable for `JSON` processing with coercions:
+  - `Types::JSON::Nil`
+  - `Types::JSON::Date`
+  - `Types::JSON::DateTime`
+  - `Types::JSON::Time`
+  - `Types::JSON::Decimal`
+  - `Types::JSON::Array`
+  - `Types::JSON::Hash`
+
+* `Maybe` strict types:
+  - `Types::Maybe::Strict::Class`
+  - `Types::Maybe::Strict::String`
+  - `Types::Maybe::Strict::Symbol`
+  - `Types::Maybe::Strict::True`
+  - `Types::Maybe::Strict::False`
+  - `Types::Maybe::Strict::Integer`
+  - `Types::Maybe::Strict::Float`
+  - `Types::Maybe::Strict::Decimal`
+  - `Types::Maybe::Strict::Date`
+  - `Types::Maybe::Strict::DateTime`
+  - `Types::Maybe::Strict::Time`
+  - `Types::Maybe::Strict::Array`
+  - `Types::Maybe::Strict::Hash`
+
+* `Maybe` coercible types:
+  - `Types::Maybe::Coercible::String`
+  - `Types::Maybe::Coercible::Integer`
+  - `Types::Maybe::Coercible::Float`
+  - `Types::Maybe::Coercible::Decimal`
+  - `Types::Maybe::Coercible::Array`
+  - `Types::Maybe::Coercible::Hash`
+
+> `Maybe` types are not available by default - they must be loaded using `Dry::Types.load_extensions(:maybe)`. See [Optional Values](/gems/dry-types/1.0/optional-values) for more information.

data/docsite/source/constraints.html.md

@@ -0,0 +1,31 @@
+---
+title: Constraints
+layout: gem-single
+name: dry-types
+---
+
+You can create constrained types that will use validation rules to check that the input is not violating any of the configured constraints. You can treat it as a lower level guarantee that you're not instantiating objects that are broken.
+
+All types support the constraints API, but not all constraints are suitable for a particular primitive, it's up to you to set up constraints that make sense.
+
+Under the hood it uses [`dry-logic`](/gems/dry-logic) and all of its predicates are supported.
+
+``` ruby
+string = Types::String.constrained(min_size: 3)
+
+string['foo']
+# => "foo"
+
+string['fo']
+# => Dry::Types::ConstraintError: "fo" violates constraints
+
+email = Types::String.constrained(
+  format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+)
+
+email["jane@doe.org"]
+# => "jane@doe.org"
+
+email["jane"]
+# => Dry::Types::ConstraintError: "jane" violates constraints
+```

data/docsite/source/custom-types.html.md

@@ -0,0 +1,93 @@
+---
+title: Custom Types
+layout: gem-single
+name: dry-types
+---
+
+There are a bunch of helpers for building your own types based on existing classes and values. These helpers are automatically defined if you're imported types in a module.
+
+### `Types.Instance`
+
+`Types.Instance` builds a type that checks if a value has the given class.
+
+```ruby
+range_type = Types.Instance(Range)
+range_type[1..2] # => 1..2
+```
+
+### `Types.Value`
+
+`Types.Value` builds a type that checks a value for equality (using `==`).
+
+```ruby
+valid = Types.Value('valid')
+valid['valid'] # => 'valid'
+valid['invalid']
+# => Dry::Types::ConstraintError: "invalid" violates constraints (eql?("valid", "invalid") failed)
+```
+
+### `Types.Constant`
+
+`Types.Constant` builds a type that checks a value for identity (using `equal?`).
+
+```ruby
+valid = Types.Constant(:valid)
+valid[:valid] # => :valid
+valid[:invalid]
+# => Dry::Types::ConstraintError: :invalid violates constraints (is?(:valid, :invalid) failed)
+```
+
+### `Types.Constructor`
+
+`Types.Constructor` builds a new constructor type for the given class. By default uses the `new` method as a constructor.
+
+```ruby
+user_type = Types.Constructor(User)
+
+# It is equivalent to User.new(name: 'John')
+user_type[name: 'John']
+
+# Using a block
+user_type = Types.Constructor(User) { |values| User.new(values) }
+```
+
+### `Types.Nominal`
+
+`Types.Nominal` wraps the given class with a simple definition without any behavior attached.
+
+```ruby
+int = Types.Nominal(Integer)
+int[1] # => 1
+
+# The type doesn't have any checks
+int['one'] # => 'one'
+```
+
+### `Types.Hash`
+
+`Types.Hash` builds a new hash schema.
+
+```ruby
+# In the full form
+Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
+
+# Using Types.Hash()
+Types.Hash(:permissive, name: Types::String, age: Types::Coercible::Integer)
+```
+
+### `Types.Array`
+
+`Types.Array` is a shortcut for `Types::Array.of`
+
+```ruby
+ListOfStrings = Types.Array(Types::String)
+```
+
+### `Types.Interface`
+
+`Types.Interface` builds a type that checks a value responds to given methods.
+
+```ruby
+Callable = Types.Interface(:call)
+Contact = Types.Interface(:name, :phone)
+```

data/docsite/source/default-values.html.md

@@ -0,0 +1,91 @@
+---
+title: Default Values
+layout: gem-single
+name: dry-types
+---
+
+A type with a default value will return the configured value when the input is not defined:
+
+``` ruby
+PostStatus = Types::String.default('draft')
+
+PostStatus[] # "draft"
+PostStatus["published"] # "published"
+PostStatus[true] # raises ConstraintError
+```
+
+It works with a callable value:
+
+``` ruby
+CallableDateTime = Types::DateTime.default { DateTime.now }
+
+CallableDateTime[]
+# => #<DateTime: 2017-05-06T00:43:06+03:00 ((2457879j,78186s,649279000n),+10800s,2299161j)>
+CallableDateTime[]
+# => #<DateTime: 2017-05-06T00:43:07+03:00 ((2457879j,78187s,635494000n),+10800s,2299161j)>
+```
+
+`Dry::Types::Undefined` can be passed explicitly as a missing value:
+
+```ruby
+PostStatus = Types::String.default('draft')
+
+PostStatus[Dry::Types::Undefined] # "draft"
+```
+
+It also receives the type constructor as an argument:
+
+```ruby
+CallableDateTime = Types::DateTime.constructor(&:to_datetime).default { |type| type[Time.now] }
+
+CallableDateTime[Time.now]
+# => #<DateTime: 2017-05-06T01:13:06+03:00 ((2457879j,79986s,63464000n),+10800s,2299161j)>
+CallableDateTime[Date.today]
+# => #<DateTime: 2017-05-06T00:00:00+00:00 ((2457880j,0s,0n),+0s,2299161j)>
+CallableDateTime[]
+# => #<DateTime: 2017-05-06T01:13:06+03:00 ((2457879j,79986s,63503000n),+10800s,2299161j)>
+```
+
+**Be careful:** types will return the **same instance** of the default value every time. This may cause problems if you mutate the returned value after receiving it:
+
+```ruby
+default_0 = PostStatus.()
+# => "draft"
+default_1 = PostStatus.()
+# => "draft"
+
+# Both variables point to the same string:
+default_0.object_id == default_1.object_id
+# => true
+
+# Mutating the string will change the default value of type:
+default_0 << '_mutated'
+PostStatus.(nil)
+# => "draft_mutated" # not "draft"
+```
+
+You can guard against these kind of errors by calling `freeze` when setting the default:
+
+```ruby
+PostStatus = Types::Params::String.default('draft'.freeze)
+default = PostStatus.()
+default << 'attempt to mutate default'
+# => RuntimeError: can't modify frozen string
+
+# If you really want to mutate it, call `dup` on it first:
+default = default.dup
+default << "this time it'll work"
+```
+
+**Warning on using with constrained types**: If the value passed to the `.default` block does not match the type constraints, this will not throw an exception, because it is not passed to the constructor and will be used as is.
+
+```ruby
+CallableDateTime = Types::DateTime.constructor(&:to_datetime).default { Time.now }
+
+CallableDateTime[Time.now]
+# => #<DateTime: 2017-05-06T00:50:09+03:00 ((2457879j,78609s,839588000n),+10800s,2299161j)>
+CallableDateTime[Date.today]
+# => #<DateTime: 2017-05-06T00:00:00+00:00 ((2457880j,0s,0n),+0s,2299161j)>
+CallableDateTime[]
+# => 2017-05-06 00:50:15 +0300
+```