dry-data 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0d798aac2e4dd90dc419ed04f7366d04a5aae2a1
-  data.tar.gz: 35060cab0302057a57e3f098ec2842cb9824840d
+  metadata.gz: 1b1120eb4914c94c999641d81a01ede2deb790f2
+  data.tar.gz: 58700f1d2f8d0de68428212b15feba6111de499f
 SHA512:
-  metadata.gz: b60ca79d4da30f0af580450b3ea05b4d2fc09cf45235f419ef38d7de4a0f0e87cb5640e925433d7aa5d6a6a3153447b7505f973e9460e23a529ded9903827893
-  data.tar.gz: d71b05244589161fbe4a464f11eeb56ed94b7a8408b4c29e6ad934231b998545e9b3fdf3ba4bbcc01c097763489c6c0a43571f7b91a14f831a63cb859494a9d5
+  metadata.gz: 12003922d8e399f312bb39ebc53c5f37bde3be4a7c5d5d9e3d667fb97358df733810fe096c60c0ca831f9dbcad7ed3b9b8cd81f2017699d12cbe8b950d4bfa05
+  data.tar.gz: ff1ee72ab2ea48e10458352e82a1d07521f644760107b33f66b67bda5f1067c7dcb77c9fb0d609489a2d278a92c1fe11d139c88d508fe67415a87155fdd5701d

data/.travis.yml

@@ -8,6 +8,7 @@ rvm:
   - 2.0
   - 2.1
   - 2.2
+  - 2.3.0
   - rbx-2
   - jruby-9000
   - ruby-head

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# v0.5.0 2016-01-11
+
+## Added
+
+* `Type#default` interface for defining a type with a default value (solnic)
+
+## Changed
+
+* [BREAKING] `Dry::Data::Type.new` accepts constructor and *options* now (solnic)
+* Renamed `Dry::Data::Type::{Enum,Constrained}` => `Dry::Data::{Enum,Constrained}` (solnic)
+* `dry-logic` is now a dependency for constrained types (solnic)
+* Constrained types are now always available (solnic)
+* `strict.*` category uses constrained types with `:type?` predicate (solnic)
+* `SumType#call` no longer needs to rescue from `TypeError` (solnic)
+
+## Fixed
+
+* `attribute` raises proper error when type definition is missing (solnic)
+
+[Compare v0.4.2...v0.5.0](https://github.com/dryrb/dry-data/compare/v0.4.2...v0.5.0)
+
 # v0.4.2 2015-12-27
 
 ## Added

data/Gemfile

@@ -2,8 +2,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'dry-validation'
-
 group :tools do
   gem 'byebug', platform: :mri
 end

data/README.md

@@ -14,7 +14,50 @@
 [![Test Coverage](https://codeclimate.com/github/dryrb/dry-data/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/dryrb/dry-data.svg?branch=master)][inchpages]
 
-A simple type system for Ruby with support for coercions.
+A simple and extendible type system for Ruby with support for kernel coercions,
+form coercions, sum types, constrained types and default-value types.
+
+Used by:
+
+* [dry-validation](https://github.com/dryrb/dry-validation) for params coercions
+* [rom-repository](https://github.com/rom-rb/rom-repository) for auto-mapped structs
+* [rom](https://github.com/rom-rb/rom)'s adapters for relation schema definitions
+* your project...?
+
+Articles:
+
+* ["Invalid Object Is An Anti-Pattern"](http://solnic.eu/2015/12/28/invalid-object-is-an-anti-pattern.html)
+
+## dry-data vs virtus
+
+[Virtus](https://github.com/solnic/virtus) has been a successful library, unfortunately
+it is "only" a by-product of an ActiveRecord ORM which carries many issues typical
+to ActiveRecord-like features that we all know from Rails, especially when it
+comes to very complicated coercion logic, mixing unrelated concerns, polluting
+application layer with concerns that should be handled at the bounderies etc.
+
+`dry-data` has been created to become a better tool that solves *similar* (but
+not identical!) problems related to type-safety and coercions. It is a superior
+solution because:
+
+* Types are [categorized](#built-in-type-categories), which is especially important for coercions
+* Types are objects and they are easily reusable
+* Has [structs](#structs) and [values](#values) with *a simple DSL*
+* Has [constrained types](#constrained-types)
+* Has [optional types](#optional-types)
+* Has [defaults](#defaults)
+* Has [sum-types](#sum-types)
+* Has [enums](#enums)
+* Has [hash type with type schemas](#hashes)
+* Has [array type with member type](#arrays)
+* Suitable for many use-cases while remaining simple, in example:
+  * Params coercions
+  * Domain "models"
+  * Defining various domain-specific, shared information using enums or values
+  * Annotating objects
+  * and more...
+* There's no const-missing magic and complicated const lookups like in Virtus
+* AND is roughly 10-12x faster than Virtus
 
 ## Installation
 
@@ -46,107 +89,139 @@ Built-in types are grouped under 5 categories:
 - `form` - non-strict coercion types suitable for form params
 - `maybe` - accepts either a nil or something else
 
+### Configuring Types Module
+
+In `dry-data` a type is an object with a constructor that knows how to handle
+input. On top of that there are high-level types like a sum-type, constrained type,
+optional type or default value type.
+
+To acccess all the built-in type objects you can configure `dry-data` with a
+namespace module:
+
+``` ruby
+module Types
+end
+
+Dry::Data.configure do |config|
+  config.namespace = Types
+end
+
+# after defining your custom types (if you've got any) you can finalize setup
+Dry::Data.finalize
+
+# this defines all types under your namespace, in example:
+Types::Coercible::String
+# => #<Dry::Data::Type:0x007feffb104aa8 @constructor=#<Method: Kernel.String>, @primitive=String>
+```
+
+With types accessible as constants you can easily compose more complex types,
+like sum-types or constrained types, in hash schemas or structs:
+
+``` ruby
+Dry::Data.configure do |config|
+  config.namespace = Types
+end
+
+Dry::Data.finalize
+
+module Types
+  Email = String.constrained(format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i)
+  Age = Int.constrained(gt: 18)
+end
+
+class User < Dry::Data::Struct
+  attribute :name, Types::String
+  attribute :email, Types::Email
+  attribute :age, Types::Age
+end
+```
+
 ### Built-in Type Categories
 
+Assuming you configured types under `Types` module namespace:
+
 Non-coercible:
 
-- `nil`
-- `symbol`
-- `class`
-- `true`
-- `false`
-- `date`
-- `date_time`
-- `time`
+- `Types::Nil`
+- `Types::Symbol`
+- `Types::Class`
+- `Types::True`
+- `Types::False`
+- `Types::Date`
+- `Types::DateTime`
+- `Types::Time`
 
 Coercible types using kernel coercion methods:
 
-- `coercible.string`
-- `coercible.int`
-- `coercible.float`
-- `coercible.decimal`
-- `coercible.array`
-- `coercible.hash`
+- `Types::Coercible::String`
+- `Types::Coercible::Int`
+- `Types::Coercible::Float`
+- `Types::Coercible::Decimal`
+- `Types::Coercible::Array`
+- `Types::Coercible::Hash`
 
 Optional strict types:
 
-- `maybe.strict.string`
-- `maybe.strict.int`
-- `maybe.strict.float`
-- `maybe.strict.decimal`
-- `maybe.strict.array`
-- `maybe.strict.hash`
+- `Types::Maybe::Strict::String`
+- `Types::Maybe::Strict::Int`
+- `Types::Maybe::Strict::Float`
+- `Types::Maybe::Strict::Decimal`
+- `Types::Maybe::Strict::Array`
+- `Types::Maybe::Strict::Hash`
 
 Optional coercible types:
 
-- `maybe.coercible.string`
-- `maybe.coercible.int`
-- `maybe.coercible.float`
-- `maybe.coercible.decimal`
-- `maybe.coercible.array`
-- `maybe.coercible.hash`
+- `Types::Maybe::Coercible::String`
+- `Types::Maybe::Coercible::Int`
+- `Types::Maybe::Coercible::Float`
+- `Types::Maybe::Coercible::Decimal`
+- `Types::Maybe::Coercible::Array`
+- `Types::Maybe::Coercible::Hash`
 
 Coercible types suitable for form param processing:
 
-- `form.nil`
-- `form.date`
-- `form.date_time`
-- `form.time`
-- `form.true`
-- `form.false`
-- `form.bool`
-- `form.int`
-- `form.float`
-- `form.decimal`
+- `Types::Form::Nil`
+- `Types::Form::Date`
+- `Types::Form::DateTime`
+- `Types::Form::Time`
+- `Types::Form::True`
+- `Types::Form::False`
+- `Types::Form::Bool`
+- `Types::Form::Int`
+- `Types::Form::Float`
+- `Types::Form::Decimal`
 
-### Accessing Built-in Types
+### Strict vs Coercible Types
 
 ``` ruby
-# default passthrough category
-float = Dry::Data["float"]
-
-float[3.2] # => 3.2
-float["3.2"] # "3.2"
-
-# strict type-check category
-int = Dry::Data["strict.int"]
-
-int[1] # => 1
-int['1'] # => raises TypeError
+Types::Strict::Int[1] # => 1
+Types::Strict::Int['1'] # => raises Dry::Data::ConstraintError
 
 # coercible type-check group
-string = Dry::Data["coercible.string"]
-array = Dry::Data["coercible.array"]
-
-string[:foo] # => 'foo'
-array[:foo] # => [:foo]
+Types::Coercible::String[:foo] # => 'foo'
+Types::Coercible::Array[:foo] # => [:foo]
 
 # form group
-date = Dry::Data["form.date"]
-date['2015-11-29'] # => #<Date: 2015-11-29 ((2457356j,0s,0n),+0s,2299161j)>
+Types::Form::Date['2015-11-29'] # => #<Date: 2015-11-29 ((2457356j,0s,0n),+0s,2299161j)>
 ```
 
-### Optional types
+### Optional Types
 
 All built-in types have their optional versions too, you can access them under
-`"maybe.strict"` and `"maybe.coercible"` categories:
+`"Types::Maybe::Strict"` and `"Maybe::Coercible"` categories:
 
 ``` ruby
-maybe_int = Dry::Data["maybe.strict.int"]
-
-maybe_int[nil] # None
-maybe_int[123] # Some(123)
+Types::Maybe::Int[nil] # None
+Types::Maybe::Int[123] # Some(123)
 
-maybe_coercible_float = Dry::Data["maybe.coercible.float"]
-
-maybe_int[nil] # None
-maybe_int['12.3'] # Some(12.3)
+Types::Maybe::Coercible::Float[nil] # None
+Types::Maybe::Coercible::Float['12.3'] # Some(12.3)
 ```
 
 You can define your own optional types too:
 
 ``` ruby
-maybe_string = Dry::Data["string"].optional
+maybe_string = Types::Strict::String.optional
 
 maybe_string[nil]
 # => None
@@ -164,19 +239,31 @@ maybe_string['something'].fmap(&:upcase).value
 # => "SOMETHING"
 ```
 
+### Defaults
+
+A type with a default value will return the configured value when the input is `nil`:
+
+``` ruby
+PostStatus = Types::Strict::String.default('draft')
+
+PostStatus[nil] # "draft"
+PostStatus["published"] # "published"
+PostStatus[true] # raises ConstraintError
+```
+
 ### Sum-types
 
 You can specify sum types using `|` operator, it is an explicit way of defining
 what are the valid types of a value.
 
 In example `dry-data` defines `bool` type which is a sum-type consisting of `true`
-and `false` types which is expressed as `Dry::Data['true'] | Dry::Data['false']`
+and `false` types which is expressed as `Types::True | Types::False`
 (and it has its strict version, too).
 
 Another common case is defining that something can be either `nil` or something else:
 
 ``` ruby
-nil_or_string = Dry::Data['strict.nil'] | Dry::Data['strict.string']
+nil_or_string = Types::Nil | Types::Strict::String
 
 nil_or_string[nil] # => nil
 nil_or_string["hello"] # => "hello"
@@ -191,20 +278,11 @@ a lower level guarantee that you're not instantiating objects that are broken.
 All types support 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-validation`](https://github.com/dryrb/dry-validation)
+Under the hood it uses [`dry-logic`](https://github.com/dryrb/dry-logic)
 and all of its predicates are supported.
 
-IMPORTANT: `dry-data` does not have a runtime dependency on `dry-validation` so
-if you want to use contrained types you need to add it to your Gemfile
-
-If you want to use constrained type you need to require it explicitly:
-
 ``` ruby
-require "dry/data/type/constrained"
-```
-
-``` ruby
-string = Dry::Data["strict.string"].constrained(min_size: 3)
+string = Types::Strict::String.constrained(min_size: 3)
 
 string['foo']
 # => "foo"
@@ -212,7 +290,7 @@ string['foo']
 string['fo']
 # => Dry::Data::ConstraintError: "fo" violates constraints
 
-email = Dry::Data['strict.string'].constrained(
+email = Types::Strict::String.constrained(
   format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
 )
 
@@ -223,48 +301,7 @@ email["jane"]
 # => Dry::Data::ConstraintError: "fo" violates constraints
 ```
 
-### Setting Type Constants
-
-Types can be stored as easily accessible constants in a configured namespace:
-
-``` ruby
-module Types; end
-
-Dry::Data.configure do |config|
-  config.namespace = Types
-end
-
-# after defining your custom types (if you've got any) you can finalize setup
-Dry::Data.finalize
-
-# this defines all types under your namespace
-Types::Coercible::String
-# => #<Dry::Data::Type:0x007feffb104aa8 @constructor=#<Method: Kernel.String>, @primitive=String>
-```
-
-With types accessible as constants you can easily compose more complex types,
-like sum-types or constrained types, in hash schemas or structs:
-
-``` ruby
-Dry::Data.configure do |config|
-  config.namespace = Types
-end
-
-Dry::Data.finalize
-
-module Types
-  Email = String.constrained(format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i)
-  Age = Int.constrained(gt: 18)
-end
-
-class User < Dry::Data::Struct
-  attribute :name, Types::String
-  attribute :email, Types::Email
-  attribute :age, Types::Age
-end
-```
-
-### Defining Enums
+### Enums
 
 In many cases you may want to define an enum. For example in a blog application
 a post may have a finite list of statuses. Apart from accessing the current status
@@ -272,8 +309,6 @@ value it is useful to have all possible values accessible too. Furthermore an
 enum is a `int => value` map, so you can store integers somewhere and have them
 mapped to enum values conveniently.
 
-You can define enums for every type but it probably only makes sense for `string`:
-
 ``` ruby
 # assuming we have types loaded into `Types` namespace
 # we can easily define an enum for our post struct
@@ -303,77 +338,102 @@ Post::Statuses[nil]
 # => Dry::Data::ConstraintError: nil violates constraints
 ```
 
-### Defining a hash with explicit schema
+### Hashes
 
 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.
 
-### Hash Schema
+#### Hash Schema
 
 ``` ruby
 # using simple kernel coercions
-hash = Dry::Data['hash'].schema(name: 'string', age: 'coercible.int')
+hash = Types::Hash.schema(name: Types::String, age: Types::Coercible::Int)
 
 hash[name: 'Jane', age: '21']
 # => { :name => "Jane", :age => 21 }
 
 # using form param coercions
-hash = Dry::Data['hash'].schema(name: 'string', birthdate: 'form.date')
+hash = Types::Hash.schema(name: Types::String, birthdate: Form::Date)
 
 hash[name: 'Jane', birthdate: '1994-11-11']
 # => { :name => "Jane", :birthdate => #<Date: 1994-11-11 ((2449668j,0s,0n),+0s,2299161j)> }
 ```
 
-### Strict Hash
+#### Strict Schema
 
 Strict hash will raise errors when keys are missing or value types are incorrect.
 
 ``` ruby
-hash = Dry::Data['hash'].strict(name: 'string', age: 'coercible.int')
+hash = Types::Hash.strict(name: 'string', age: 'coercible.int')
 
 hash[email: 'jane@doe.org', name: 'Jane', age: 21]
 # => Dry::Data::SchemaKeyError: :email is missing in Hash input
 ```
 
-### Symbolized Hash
+#### Symbolized Schema
 
 Symbolized hash will turn string key names into symbols
 
 ``` ruby
-hash = Dry::Data['hash'].symbolized(name: 'string', age: 'coercible.int')
+hash = Types::Hash.symbolized(name: Types::String, age: Types::Coercible::Int)
 
 hash['name' => 'Jane', 'age' => '21']
 # => { :name => "Jane", :age => 21 }
 ```
 
-### Defining a struct
+### Arrays
 
-You can define struct objects which will have attribute readers for specified
-attributes using a simple dsl:
+The built-in array type supports defining member type:
+
+``` ruby
+PostStatuses = Types::Strict::Array.member(Types::Coercible::String)
+
+PostStatuses[[:foo, :bar]] # ["foo", "bar"]
+```
+
+### Structs
+
+You can define struct objects which will have readers for specified attributes
+using a simple dsl:
 
 ``` ruby
 class User < Dry::Data::Struct
-  attribute :name, "maybe.coercible.string"
-  attribute :age, "coercible.int"
+  attribute :name, Types::Maybe::Coercible::String
+  attribute :age, Types::Coercible::Int
 end
 
-# becomes available like any other type
-user_type = Dry::Data["user"]
-
-user = user_type[name: nil, age: '21']
+user = User.new(name: nil, age: '21')
 
 user.name # None
 user.age # 21
 
-user = user_type[name: 'Jane', age: '21']
+user = User(name: 'Jane', age: '21')
 
 user.name # => Some("Jane")
 user.age # => 21
 ```
 
+### Values
+
+You can define value objects which will behave like structs and have equality
+methods too:
+
+``` ruby
+class Location < Dry::Data::Value
+  attribute :lat, Types::Strict::Float
+  attribute :lat, Types::Strict::Float
+end
+
+loc1 = Location.new(lat: 1.23, lng: 4.56)
+loc2 = Location.new(lat: 1.23, lng: 4.56)
+
+loc1 == loc2
+# true
+```
+
 ## Status and Roadmap
 
-This library is in an early stage of development but you are encauraged to try it
+This library is in an early stage of development but you are encouraged to try it
 out and provide feedback.
 
 For planned features check out [the issues](https://github.com/dryrb/dry-data/labels/feature).

data/dry-data.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'dry-container', '~> 0.2'
   spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
   spec.add_runtime_dependency 'dry-configurable', '~> 0.1'
+  spec.add_runtime_dependency 'dry-logic', '~> 0.1'
   spec.add_runtime_dependency 'inflecto', '~> 0.0.0', '>= 0.0.2'
   spec.add_runtime_dependency 'kleisli', '~> 0.2'
 

data/lib/dry/data.rb

@@ -13,7 +13,6 @@ require 'dry/data/container'
 require 'dry/data/type'
 require 'dry/data/struct'
 require 'dry/data/value'
-require 'dry/data/dsl'
 
 module Dry
   module Data
@@ -53,7 +52,7 @@ module Dry
     def self.register_class(klass)
       container.register(
         Inflecto.underscore(klass).gsub('/', '.'),
-        Type.new(klass.method(:new), klass)
+        Type.new(klass.method(:new), primitive: klass)
       )
     end
 
@@ -98,11 +97,6 @@ module Dry
       Inflecto.underscore(klass).gsub('/', '.')
     end
 
-    def self.type(*args, &block)
-      dsl = DSL.new(container)
-      block ? yield(dsl) : registry[args.first]
-    end
-
     def self.type_map
       @type_map ||= ThreadSafe::Cache.new
     end

data/lib/dry/data/constrained.rb

@@ -0,0 +1,41 @@
+require 'dry/data/decorator'
+require 'dry/data/constraints'
+
+module Dry
+  module Data
+    class Constrained
+      include Decorator
+      include TypeBuilder
+
+      attr_reader :rule
+
+      def initialize(type, options)
+        super
+        @rule = options.fetch(:rule)
+      end
+
+      def call(input)
+        result = try(input)
+
+        if valid?(result)
+          result
+        else
+          raise ConstraintError, "#{input.inspect} violates constraints"
+        end
+      end
+      alias_method :[], :call
+
+      def try(input)
+        type[input]
+      end
+
+      def valid?(input)
+        super && rule.(input).success?
+      end
+
+      def constrained(options)
+        with(rule: rule & Data.Rule(primitive, options))
+      end
+    end
+  end
+end

data/lib/dry/data/constraints.rb

@@ -1,8 +1,16 @@
-require 'dry/validation/rule_compiler'
-require 'dry/validation/predicates'
+require 'dry/logic/rule_compiler'
+require 'dry/logic/predicates'
 
 module Dry
   module Data
+    module Predicates
+      include Logic::Predicates
+
+      predicate(:type?) do |type, value|
+        value.kind_of?(type)
+      end
+    end
+
     def self.Rule(primitive, options)
       rule_compiler.(
         options.map { |key, val|
@@ -12,7 +20,7 @@ module Dry
     end
 
     def self.rule_compiler
-      @rule_compiler ||= Validation::RuleCompiler.new(Validation::Predicates)
+      @rule_compiler ||= Logic::RuleCompiler.new(Data::Predicates)
     end
   end
 end

data/lib/dry/data/decorator.rb

@@ -0,0 +1,44 @@
+module Dry
+  module Data
+    module Decorator
+      attr_reader :type, :options
+
+      def initialize(type, options = {})
+        @type = type
+        @options = options
+      end
+
+      def constructor
+        type.constructor
+      end
+
+      def valid?(input)
+        type.valid?(input)
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
+      def with(new_options)
+        self.class.new(type, options.merge(new_options))
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        if type.respond_to?(meth)
+          response = type.__send__(meth, *args, &block)
+
+          if response.kind_of?(type.class)
+            self.class.new(response, options)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/data/default.rb

@@ -0,0 +1,22 @@
+require 'dry/data/decorator'
+
+module Dry
+  module Data
+    class Default
+      include Decorator
+      include TypeBuilder
+
+      attr_reader :value
+
+      def initialize(type, options)
+        super
+        @value = options.fetch(:value)
+      end
+
+      def call(input)
+        input.nil? ? value : type[input]
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/data/enum.rb

@@ -0,0 +1,24 @@
+require 'dry/data/decorator'
+
+module Dry
+  module Data
+    class Enum
+      include Decorator
+
+      attr_reader :values
+
+      def initialize(type, options)
+        super
+        @values = options.fetch(:values).freeze
+        @values.each(&:freeze)
+      end
+
+      def call(input)
+        case input
+        when Fixnum then type[values[input]]
+        else type[input] end
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/data/optional.rb

@@ -1,15 +1,10 @@
+require 'dry/data/decorator'
+
 module Dry
   module Data
     class Optional
-      attr_reader :type
-
-      def initialize(type)
-        @type = type
-      end
-
-      def valid?(input)
-        type.valid?(input)
-      end
+      include Decorator
+      include TypeBuilder
 
       def call(input)
         Maybe(type[input])

data/lib/dry/data/struct.rb

@@ -10,8 +10,8 @@ module Dry
         Data.register_class(klass) unless klass == Value
       end
 
-      def self.attribute(*args)
-        attributes(Hash[[args]])
+      def self.attribute(name, type)
+        attributes(name => type)
       end
 
       def self.attributes(new_schema)

data/lib/dry/data/sum_type.rb

@@ -16,16 +16,12 @@ module Dry
       end
 
       def call(input)
-        begin
-          value = left[input]
+        value = left.try(input)
 
-          if left.valid?(value)
-            value
-          else
-            right[value]
-          end
-        rescue TypeError
-          right[input]
+        if left.valid?(value)
+          value
+        else
+          right[value]
         end
       end
       alias_method :[], :call

data/lib/dry/data/type.rb

@@ -1,35 +1,18 @@
 require 'dry/data/type/hash'
 require 'dry/data/type/array'
-require 'dry/data/type/enum'
-
-require 'dry/data/sum_type'
-require 'dry/data/optional'
+require 'dry/data/type_builder'
 
 module Dry
   module Data
     class Type
-      attr_reader :constructor
-      attr_reader :primitive
+      include Dry::Equalizer(:constructor, :options)
+      include TypeBuilder
 
-      class Constrained < Type
-        attr_reader :rule
-
-        def initialize(constructor, primitive, rule)
-          super(constructor, primitive)
-          @rule = rule
-        end
+      attr_reader :constructor
 
-        def call(input)
-          result = super(input)
+      attr_reader :options
 
-          if rule.(result).success?
-            result
-          else
-            raise ConstraintError, "#{input.inspect} violates constraints"
-          end
-        end
-        alias_method :[], :call
-      end
+      attr_reader :primitive
 
       def self.[](primitive)
         if primitive == ::Array
@@ -41,29 +24,14 @@ module Dry
         end
       end
 
-      def self.strict_constructor(primitive, input)
-        if input.is_a?(primitive)
-          input
-        else
-          raise TypeError, "#{input.inspect} has invalid type"
-        end
-      end
-
-      def self.passthrough_constructor(input)
+      def self.constructor(input)
         input
       end
 
-      def initialize(constructor, primitive)
+      def initialize(constructor, options = {})
         @constructor = constructor
-        @primitive = primitive
-      end
-
-      def enum(*values)
-        Enum.new(values, constrained(inclusion: values))
-      end
-
-      def optional
-        Optional.new(Data['nil'] | self)
+        @options = options
+        @primitive = options.fetch(:primitive)
       end
 
       def name
@@ -75,12 +43,12 @@ module Dry
       end
       alias_method :[], :call
 
-      def valid?(input)
-        input.is_a?(primitive)
+      def try(input)
+        call(input)
       end
 
-      def |(other)
-        SumType.new(self, other)
+      def valid?(input)
+        input.is_a?(primitive)
       end
     end
   end

data/lib/dry/data/type/array.rb

@@ -16,7 +16,7 @@ module Dry
           array_constructor = self.class
             .method(:constructor).to_proc.curry.(constructor, member_constructor)
 
-          self.class.new(array_constructor, primitive)
+          self.class.new(array_constructor, primitive: primitive, member: member_constructor)
         end
       end
     end

data/lib/dry/data/type/hash.rb

@@ -58,7 +58,7 @@ module Dry
 
           self.class.new(
             self.class.method(meth).to_proc.curry.(constructor, value_constructors),
-            primitive
+            primitive: primitive, schema: value_constructors
           )
         end
       end

data/lib/dry/data/type_builder.rb

@@ -0,0 +1,31 @@
+module Dry
+  module Data
+    module TypeBuilder
+      def |(other)
+        SumType.new(self, other)
+      end
+
+      def optional
+        Optional.new(Data['nil'] | self)
+      end
+
+      def constrained(options)
+        Constrained.new(self, rule: Data.Rule(primitive, options))
+      end
+
+      def default(value)
+        Default.new(self, value: value)
+      end
+
+      def enum(*values)
+        Enum.new(constrained(inclusion: values), values: values)
+      end
+    end
+  end
+end
+
+require 'dry/data/default'
+require 'dry/data/constrained'
+require 'dry/data/enum'
+require 'dry/data/optional'
+require 'dry/data/sum_type'

data/lib/dry/data/types.rb

@@ -26,7 +26,7 @@ module Dry
     COERCIBLE.each do |name, primitive|
       register(
         "coercible.#{name}",
-        Type[primitive].new(Kernel.method(primitive.name), primitive)
+        Type[primitive].new(Kernel.method(primitive.name), primitive: primitive)
       )
     end
 
@@ -34,7 +34,7 @@ module Dry
     ALL_PRIMITIVES.each do |name, primitive|
       register(
         "strict.#{name}",
-        Type[primitive].new(Type.method(:strict_constructor).to_proc.curry.(primitive), primitive)
+        Type[primitive].new(Type.method(:constructor), primitive: primitive).constrained(type: primitive)
       )
     end
 
@@ -42,7 +42,7 @@ module Dry
     ALL_PRIMITIVES.each do |name, primitive|
       register(
         name.to_s,
-        Type[primitive].new(Type.method(:passthrough_constructor), primitive)
+        Type[primitive].new(Type.method(:constructor), primitive: primitive)
       )
     end
 

data/lib/dry/data/types/form.rb

@@ -3,27 +3,27 @@ require 'dry/data/coercions/form'
 module Dry
   module Data
     register('form.nil') do
-      Type.new(Coercions::Form.method(:to_nil), NilClass)
+      Type.new(Coercions::Form.method(:to_nil), primitive: NilClass)
     end
 
     register('form.date') do
-      Type.new(Coercions::Form.method(:to_date), Date)
+      Type.new(Coercions::Form.method(:to_date), primitive: Date)
     end
 
     register('form.date_time') do
-      Type.new(Coercions::Form.method(:to_date_time), DateTime)
+      Type.new(Coercions::Form.method(:to_date_time), primitive: DateTime)
     end
 
     register('form.time') do
-      Type.new(Coercions::Form.method(:to_time), Time)
+      Type.new(Coercions::Form.method(:to_time), primitive: Time)
     end
 
     register('form.true') do
-      Type.new(Coercions::Form.method(:to_true), TrueClass)
+      Type.new(Coercions::Form.method(:to_true), primitive: TrueClass)
     end
 
     register('form.false') do
-      Type.new(Coercions::Form.method(:to_false), FalseClass)
+      Type.new(Coercions::Form.method(:to_false), primitive: FalseClass)
     end
 
     register('form.bool') do
@@ -31,15 +31,15 @@ module Dry
     end
 
     register('form.int') do
-      Type.new(Coercions::Form.method(:to_int), Fixnum)
+      Type.new(Coercions::Form.method(:to_int), primitive: Fixnum)
     end
 
     register('form.float') do
-      Type.new(Coercions::Form.method(:to_float), Float)
+      Type.new(Coercions::Form.method(:to_float), primitive: Float)
     end
 
     register('form.decimal') do
-      Type.new(Coercions::Form.method(:to_decimal), BigDecimal)
+      Type.new(Coercions::Form.method(:to_decimal), primitive: BigDecimal)
     end
   end
 end

data/lib/dry/data/value.rb

@@ -1,3 +1,5 @@
+require 'dry/data/struct'
+
 module Dry
   module Data
     class Value < Struct

data/lib/dry/data/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Data
-    VERSION = '0.4.2'.freeze
+    VERSION = '0.5.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-data
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-27 00:00:00.000000000 Z
+date: 2016-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thread_safe
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: dry-logic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: inflecto
   requirement: !ruby/object:Gem::Requirement
@@ -166,17 +180,19 @@ files:
 - lib/dry/data.rb
 - lib/dry/data/coercions/form.rb
 - lib/dry/data/compiler.rb
+- lib/dry/data/constrained.rb
 - lib/dry/data/constraints.rb
 - lib/dry/data/container.rb
-- lib/dry/data/dsl.rb
+- lib/dry/data/decorator.rb
+- lib/dry/data/default.rb
+- lib/dry/data/enum.rb
 - lib/dry/data/optional.rb
 - lib/dry/data/struct.rb
 - lib/dry/data/sum_type.rb
 - lib/dry/data/type.rb
 - lib/dry/data/type/array.rb
-- lib/dry/data/type/constrained.rb
-- lib/dry/data/type/enum.rb
 - lib/dry/data/type/hash.rb
+- lib/dry/data/type_builder.rb
 - lib/dry/data/types.rb
 - lib/dry/data/types/form.rb
 - lib/dry/data/value.rb

data/lib/dry/data/dsl.rb

@@ -1,15 +0,0 @@
-module Dry
-  module Data
-    class DSL
-      attr_reader :container
-
-      def initialize(container)
-        @container = container
-      end
-
-      def [](name)
-        container[name]
-      end
-    end
-  end
-end

data/lib/dry/data/type/constrained.rb

@@ -1,35 +0,0 @@
-require 'dry/data/constraints'
-
-module Dry
-  module Data
-    class Type
-      class Constrained < Type
-        attr_reader :rule
-
-        def initialize(constructor, primitive, rule)
-          super(constructor, primitive)
-          @rule = rule
-        end
-
-        def call(input)
-          result = super(input)
-
-          if valid?(result)
-            result
-          else
-            raise ConstraintError, "#{input.inspect} violates constraints"
-          end
-        end
-        alias_method :[], :call
-
-        def valid?(input)
-          super && rule.(input).success?
-        end
-      end
-
-      def constrained(options)
-        Constrained.new(constructor, primitive, Data.Rule(primitive, options))
-      end
-    end
-  end
-end

data/lib/dry/data/type/enum.rb

@@ -1,27 +0,0 @@
-module Dry
-  module Data
-    class Type
-      class Enum
-        attr_reader :values
-        attr_reader :type
-
-        def initialize(values, type)
-          @values = values.freeze
-          @type = type
-          values.each(&:freeze)
-        end
-
-        def primitive
-          type.primitive
-        end
-
-        def call(input)
-          case input
-          when Fixnum then type[values[input]]
-          else type[input] end
-        end
-        alias_method :[], :call
-      end
-    end
-  end
-end