dry-data 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 706c2f7f4ad11b612b658585553e3bb850b53b76
-  data.tar.gz: a93749b4327258e7e1a76893b4e4e9f6526b9611
+  metadata.gz: 63d84521c44133ae20569f13cfe37198d145b84b
+  data.tar.gz: 34a54445feeb95d3caffec626f3cca303eaa3455
 SHA512:
-  metadata.gz: 37ceb712ef8b4c3e62791694460d0f1a010ff0e33ea8c9db971bf99455fdf1434501f5c2003be3b8b1856ee5a138f2d78a717ff07117278b0722f5de9e055f8e
-  data.tar.gz: 752bdf83d32e5909bd183d582486b7132d19e58c5d2a50898286246c20a045476cdbfc63cddc5e324dc716f6c0a13677b3e5a352daaa50159c49ae9d10d7e9dd
+  metadata.gz: c4ed0e1ca95bdb0e7d07dd744480da21d0316d96a43dc9e52e35963edbbc45f4eca370b4116a5ef4db51f6c0dda8e68b8f0b836ab1235fd7b2850ecfaa4f4558
+  data.tar.gz: 87f09d1e60fbfef3a96750561ef81e354ced647d6e4371d02e49fd204e6229684b50e194f7ed3c6cf8c8d312e1d329b60de0f876f5a5cfca1fed9ffafb92cfe7

data/.travis.yml

@@ -9,7 +9,7 @@ rvm:
   - 2.1
   - 2.2
   - rbx-2
-  - jruby
+  - jruby-9000
   - ruby-head
   - jruby-head
 env:

data/CHANGELOG.md

@@ -1,3 +1,16 @@
-v0.0.1 2015-10-05
+# v0.1.0 2015-11-27
+
+## Added
+
+* `form.*` coercible types (solnic)
+* `Type::Hash#strict` for defining hashes with a strict schema (solnic)
+* `Type::Hash#symbolized` for defining hashes that will symbolize keys (solnic)
+* `Dry::Data.register_class` short-cut interface for registering a class and
+  setting its `.new` method as the constructor (solnic)
+* `Dry::Data::Compiler` for building a type from a simple ast (solnic)
+
+[Compare v0.0.1...HEAD](https://github.com/dryrb/dry-data/compare/v0.0.1...HEAD)
+
+# v0.0.1 2015-10-05
 
 First public release

data/README.md

@@ -24,36 +24,30 @@ Or install it yourself as:
 
     $ gem install dry-data
 
-## Why?
-
-Unlike seemingly similar libraries like virtus, attrio, fast_attrs, attribs etc.
-`Dry::Data` provides you an interface to explicitly specify data types you want
-to use in your application domain which gives you type-safety and *simple* coercion
-mechanism using built-in coercion methods on the kernel.
-
-Main difference is that `Dry::Data` is not designed to handle all kinds of complex
-coercions that are typically required when dealing with, let's say, form params
-in a web application. Its primary focus is to allow you to specify the exact shape
-of the custom application data types to avoid silly bugs that are often hard to debug
-(`NoMethodError: undefined method `size' for nil:NilClass` anyone?).
-
 ## Usage
 
-Primary usage of this library is defining domain data types that your application
-will work with. The interface consists of lower-level type definitions and a higher-level
-virtus-like interface for defining structs.
+You can use `dry-data` for defining various data types in your application, like
+domain entities and value objects or hashes with coercible values used to handle
+params.
 
+Built-in types are grouped under 5 categories:
 
-### Accessing built-in types
+- default: pass-through without any checks
+- `strict` - doesn't coerce and checks the input type against the primitive class
+- `coercible` - tries to coerce and raises type-error if it failed
+- `form` - non-strict coercion types suitable for form params
+- `maybe` - accepts either a nil or something else
+
+### Built-in Type Categories
 
 Coercible types using kernel coercion methods:
 
-- `string`
-- `int`
-- `float`
-- `decimal`
-- `array`
-- `hash`
+- `coercible.string`
+- `coercible.int`
+- `coercible.float`
+- `coercible.decimal`
+- `coercible.array`
+- `coercible.hash`
 
 Non-coercible:
 
@@ -64,14 +58,19 @@ Non-coercible:
 - `date_time`
 - `time`
 
-More types will be added soon.
+Form-coercible types:
 
-Types are grouped under 4 categories:
+- `form.date`
+- `form.date_time`
+- `form.time`
+- `form.true`
+- `form.false`
+- `form.bool`
+- `form.int`
+- `form.float`
+- `form.decimal`
 
-- default: pass-through without any checks
-- `strict` - doesn't coerce and checks the input type against the primitive class
-- `coercible` - tries to coerce and raises type-error if it failed
-- `maybe` - accepts either a nil or something else
+### Accessing Built-in Types
 
 ``` ruby
 # default passthrough category
@@ -92,6 +91,10 @@ array = Dry::Data["coercible.array"]
 
 string[:foo] # => 'foo'
 array[:foo] # => [:foo]
+
+# form group
+date = Dry::Data["form.date"]
+date['2015-11-29'] # => #<Date: 2015-11-29 ((2457356j,0s,0n),+0s,2299161j)>
 ```
 
 ### Optional types
@@ -132,8 +135,54 @@ maybe_string['something'].fmap(&:upcase).value
 # => "SOMETHING"
 ```
 
+### Defining a hash with explicit schema
+
+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
+
+``` ruby
+# using simple kernel coercions
+hash = Dry::Data['hash'].schema(name: 'string', age: '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[name: 'Jane', birthdate: '1994-11-11']
+# => { :name => "Jane", :birthdate => #<Date: 1994-11-11 ((2449668j,0s,0n),+0s,2299161j)> }
+```
+
+### Strict Hash
+
+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[email: 'jane@doe.org', name: 'Jane', age: 21]
+# => Dry::Data::SchemaKeyError: :email is missing in Hash input
+```
+
+### Symbolized Hash
+
+Symbolized hash will turn string key names into symbols
+
+``` ruby
+hash = Dry::Data['hash'].symbolized(name: 'string', age: 'coercible.int')
+
+hash['name' => 'Jane', 'age' => '21']
+# => { :name => "Jane", :age => 21 }
+```
+
 ### Defining a struct
 
+You can define struct objects which will have attribute readers for specified
+attributes using a simple dsl:
+
 ``` ruby
 class User < Dry::Data::Struct
   attribute :name, "maybe.coercible.string"

data/lib/dry-data.rb

@@ -0,0 +1 @@
+require 'dry/data'

data/lib/dry/data.rb

@@ -33,8 +33,15 @@ module Dry
       @container ||= Container.new
     end
 
-    def self.register(name, type)
-      container.register(name, type)
+    def self.register(name, type = nil, &block)
+      container.register(name, type || block.call)
+    end
+
+    def self.register_class(klass)
+      container.register(
+        Inflecto.underscore(klass).gsub('/', '.'),
+        Type.new(klass.method(:new), klass)
+      )
     end
 
     def self.[](name)

data/lib/dry/data/coercions/form.rb

@@ -0,0 +1,83 @@
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Dry
+  module Data
+    module Coercions
+      module Form
+        TRUE_VALUES = %w[1 on  t true  y yes].freeze
+        FALSE_VALUES = %w[0 off f false n no].freeze
+        BOOLEAN_MAP = Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
+
+        def self.to_date(input)
+          Date.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_date_time(input)
+          DateTime.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_time(input)
+          Time.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_true(input)
+          BOOLEAN_MAP.fetch(input, input)
+        end
+
+        def self.to_false(input)
+          BOOLEAN_MAP.fetch(input, input)
+        end
+
+        def self.to_int(input)
+          if input == ''
+            nil
+          else
+            result = input.to_i
+
+            if result === 0 && input != '0'
+              input
+            else
+              result
+            end
+          end
+        end
+
+        def self.to_float(input)
+          if input == ''
+            nil
+          else
+            result = input.to_f
+
+            if result == 0.0 && (input != '0' || input != '0.0')
+              input
+            else
+              result
+            end
+          end
+        end
+
+        def self.to_decimal(input)
+          if input == ''
+            nil
+          else
+            result = to_float(input)
+
+            if result.is_a?(Float)
+              result.to_d
+            else
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/data/compiler.rb

@@ -0,0 +1,39 @@
+module Dry
+  module Data
+    class Compiler
+      attr_reader :types
+
+      def initialize(types)
+        @types = types
+      end
+
+      def call(ast)
+        visit(ast)
+      end
+
+      def visit(node, *args)
+        send(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_type(node)
+        type, args = node
+
+        if args
+          send(:"visit_#{type}", args)
+        else
+          types[type]
+        end
+      end
+
+      def visit_hash(node)
+        constructor, schema = node
+        types['hash'].public_send(constructor, schema.map { |key| visit(key) }.reduce(:merge))
+      end
+
+      def visit_key(node)
+        name, type = node
+        { name => type }
+      end
+    end
+  end
+end

data/lib/dry/data/struct.rb

@@ -7,8 +7,7 @@ module Dry
 
       def self.inherited(klass)
         super
-        name = Inflecto.underscore(klass).gsub('/', '.')
-        Data.register(name, Type.new(klass.method(:new), klass))
+        Data.register_class(klass)
       end
 
       def self.attribute(*args)
@@ -19,7 +18,7 @@ module Dry
         prev_schema = schema || {}
 
         @schema = prev_schema.merge(new_schema)
-        @constructor = Data['coercible.hash'].schema(schema)
+        @constructor = Data['coercible.hash'].strict(schema)
 
         attr_reader(*(new_schema.keys - prev_schema.keys))
 

data/lib/dry/data/sum_type.rb

@@ -33,11 +33,15 @@ module Dry
       end
 
       def call(input)
-        begin
-          left[input]
-        rescue TypeError
+        result = left[input]
+
+        if left.valid?(result)
+          result
+        else
           right[input]
         end
+      rescue TypeError
+        right[input]
       end
       alias_method :[], :call
 

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

@@ -2,7 +2,29 @@ module Dry
   module Data
     class Type
       class Hash < Type
-        def self.constructor(hash_constructor, value_constructors, input)
+        def self.safe_constructor(hash_constructor, value_constructors, input)
+          attributes = hash_constructor[input]
+
+          value_constructors.each_with_object({}) do |(key, value_constructor), result|
+            if attributes.key?(key)
+              result[key] = value_constructor[attributes[key]]
+            end
+          end
+        end
+
+        def self.symbolized_constructor(hash_constructor, value_constructors, input)
+          attributes = hash_constructor[input]
+
+          value_constructors.each_with_object({}) do |(key, value_constructor), result|
+            key_name = key.to_s
+
+            if attributes.key?(key_name)
+              result[key.to_sym] = value_constructor[attributes[key_name]]
+            end
+          end
+        end
+
+        def self.strict_constructor(hash_constructor, value_constructors, input)
           attributes = hash_constructor[input]
 
           value_constructors.each_with_object({}) do |(key, value_constructor), result|
@@ -17,13 +39,21 @@ module Dry
           end
         end
 
-        def schema(type_map)
+        def strict(type_map)
+          schema(type_map, :strict_constructor)
+        end
+
+        def symbolized(type_map)
+          schema(type_map, :symbolized_constructor)
+        end
+
+        def schema(type_map, meth = :safe_constructor)
           value_constructors = type_map.each_with_object({}) { |(name, type_id), result|
             result[name] = Data[type_id]
           }
 
           self.class.new(
-            self.class.method(:constructor).to_proc.curry.(constructor, value_constructors),
+            self.class.method(meth).to_proc.curry.(constructor, value_constructors),
             primitive
           )
         end

data/lib/dry/data/types.rb

@@ -59,3 +59,5 @@ module Dry
     register("strict.bool", self["strict.true"] | self["strict.false"])
   end
 end
+
+require 'dry/data/types/form'

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

@@ -0,0 +1,41 @@
+require 'dry/data/coercions/form'
+
+module Dry
+  module Data
+    register('form.date') do
+      Type.new(Coercions::Form.method(:to_date), Date)
+    end
+
+    register('form.date_time') do
+      Type.new(Coercions::Form.method(:to_date_time), DateTime)
+    end
+
+    register('form.time') do
+      Type.new(Coercions::Form.method(:to_time), Time)
+    end
+
+    register('form.true') do
+      Type.new(Coercions::Form.method(:to_true), TrueClass)
+    end
+
+    register('form.false') do
+      Type.new(Coercions::Form.method(:to_true), FalseClass)
+    end
+
+    register('form.bool') do
+      self['form.true'] | self['form.false']
+    end
+
+    register('form.int') do
+      Type.new(Coercions::Form.method(:to_int), Fixnum)
+    end
+
+    register('form.float') do
+      Type.new(Coercions::Form.method(:to_float), Float)
+    end
+
+    register('form.decimal') do
+      Type.new(Coercions::Form.method(:to_decimal), BigDecimal)
+    end
+  end
+end

data/lib/dry/data/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Data
-    VERSION = '0.0.1'.freeze
+    VERSION = '0.1.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-data
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-05 00:00:00.000000000 Z
+date: 2015-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-container
@@ -119,7 +119,10 @@ files:
 - bin/console
 - bin/setup
 - dry-data.gemspec
+- lib/dry-data.rb
 - lib/dry/data.rb
+- lib/dry/data/coercions/form.rb
+- lib/dry/data/compiler.rb
 - lib/dry/data/container.rb
 - lib/dry/data/dsl.rb
 - lib/dry/data/struct.rb
@@ -128,6 +131,7 @@ files:
 - lib/dry/data/type/array.rb
 - lib/dry/data/type/hash.rb
 - lib/dry/data/types.rb
+- lib/dry/data/types/form.rb
 - lib/dry/data/version.rb
 homepage: https://github.com/dryrb/dry-data
 licenses:
@@ -155,3 +159,4 @@ signing_key:
 specification_version: 4
 summary: Simple type-system for Ruby
 test_files: []
+has_rdoc: