dry-types 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 689634e9152c629af622ef69379633b674b6c60b7f5cd87093894de7ee8ce571
-  data.tar.gz: a23593e6c4d904343dadd46f919cfead42b45fbe963995380712f4c6a8e719fd
+  metadata.gz: 87e78ecf331ef9c4d95759bf28c2694e413df18fd0397d3c3c51380320328417
+  data.tar.gz: ca84bf0a23d37d7f0beda024d573852d2a0701a76f54dee2255166981bd716c5
 SHA512:
-  metadata.gz: 88fd3e79ea403515fe242baa57c6824757bdc0b04f99054a9da2394c745cce54415fc3c260b35e49eed8a5240f78614efe92e052f6e6bde0e1f9b961a04f41ac
-  data.tar.gz: 3445b5726dd5325261965409883b6830450f3d710ae2b0a7be411b0d45cb25d3550a25827d9f0661dfbfd0fd55f15954d77335312237c3bf754ca7af5eae6079
+  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,71 @@
+# 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
+
+- A bug where meta was lost for lax array types (flash-gordon)
+
+[Compare v1.1.0...v1.1.1](https://github.com/dry-rb/dry-types/compare/v1.1.0...v1.1.1)
+
 # 1.1.0 2019-07-02
 
 ## Added

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/README.md

@@ -1,5 +1,5 @@
 [gem]: https://rubygems.org/gems/dry-types
-[travis]: https://travis-ci.org/dry-rb/dry-types
+[travis]: https://travis-ci.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
@@ -8,7 +8,7 @@
 # dry-types [![Join the chat at https://dry-rb.zulipchat.com](https://img.shields.io/badge/dry--rb-join%20chat-%23346b7a.svg)][chat]
 
 [![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]
+[![Build Status](https://travis-ci.com/dry-rb/dry-types.svg?branch=master)][travis]
 [![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/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)
+```