dry-data 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51e010763886f9dde2222d1c7846875136242d2a
-  data.tar.gz: fcdcfcc354e6d9ffa962a03f9d7994e9f4ae4cf0
+  metadata.gz: 443ed733b824f1645a6e8fe1b6bc656110166920
+  data.tar.gz: 97fe87cf2594a29d4034f5323876ec654b069c9c
 SHA512:
-  metadata.gz: 04c10d34579e5a5fd825a36eba44ebc4d8b5637d9e7c4387f026188b2e17a2b148c03c27c914ce2ee40bd027a2b7b7fba731b24e88a20c8e9c89679ac0827259
-  data.tar.gz: 288618ca2bfa6b61c8e73681b1151391e388739c24fd3662607b56a18e80a5f22ad3f2544c20865fa77051bc2f494416824e0c6702bdac7d1267dfab0f556256
+  metadata.gz: 49bef55bd41e2075c3448658bc4ac79ea62c3deb3dd3a6a79fb3d30142ed389f39559beaa31352b7bc966995042093e6ec1553c7434e85d0a3e3e983d123b644
+  data.tar.gz: a4cf5f5e5f0c4d6510def73f6a4e65a6e3f59624254ee946442cf0f91943c7746224835e3cfe62b934f52043e95f1e7b85e91c3ad8f601da2e5e4003973677fd

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# v0.3.0 2015-12-09
+
+## Added
+
+* `Type#constrained` interface for defining constrained types (solnic)
+* `Dry::Data` can be configured with a type namespace (solnic)
+* `Dry::Data.finalize` can be used to define types as constants under configured namespace (solnic)
+* `Dry::Data::Type#enum` for defining an enum from a specific type (solnic)
+* New types: `symbol` and `class` along with their `strict` versions (solnic)
+
+[Compare v0.2.1...v0.3.0](https://github.com/dryrb/dry-data/compare/v0.2.1...v0.3.0)
+
 # v0.2.1 2015-11-30
 
 ## Added

data/Gemfile

@@ -2,6 +2,8 @@ source 'https://rubygems.org'
 
 gemspec
 
+gem 'dry-validation'
+
 group :tools do
   gem 'benchmark-ips'
   gem 'virtus'

data/README.md

@@ -51,6 +51,8 @@ Built-in types are grouped under 5 categories:
 Non-coercible:
 
 - `nil`
+- `symbol`
+- `class`
 - `true`
 - `false`
 - `date`
@@ -162,6 +164,121 @@ maybe_string['something'].fmap(&:upcase).value
 # => "SOMETHING"
 ```
 
+### Constrained Types
+
+You can create constrained types that will use validation rules to check if the
+input is not violating any of the configured contraints. You can treat it as
+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]
+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
+
+``` ruby
+string = Dry::Data["strict.string"].constrained(min_size: 3)
+
+string['foo']
+# => "foo"
+
+string['fo']
+# => Dry::Data::ConstraintError: "fo" violates constraints
+
+email = Dry::Data['strict.string'].constrained(
+  format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+)
+
+email["jane@doe.org"]
+# => "jane@doe.org"
+
+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
+
+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
+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
+class Post < Dry::Data::Struct
+  Statuses = Types::Strict::String.enum('draft', 'published', 'archived')
+
+  attribute :title, Types::Strict::String
+  attribute :body, Types::Strict::String
+  attribute :status, Statuses
+end
+
+# enum values are frozen, let's be paranoid, doesn't hurt and have potential to
+# eliminate silly bugs
+Post::Statuses.values.frozen? # => true
+Post::Statuses.values.all?(&:frozen?) # => true
+
+# you can access values using indices or actual values
+Post::Statuses[0] # => "draft"
+Post::Statuses['draft'] # => "draft"
+
+# it'll raise if something silly was passed in
+Post::Statuses['something silly']
+# => Dry::Data::ConstraintError: "something silly" violates constraints
+
+# nil is considered as something silly too
+Post::Statuses[nil]
+# => Dry::Data::ConstraintError: nil violates constraints
+```
+
 ### Defining a hash with explicit schema
 
 The built-in hash type has constructors that you can use to define hashes with
@@ -230,12 +347,12 @@ user.name # => Some("Jane")
 user.age # => 21
 ```
 
-## WIP
+## Status and Roadmap
 
-This is early alpha with a rough plan to:
+This library is in an early stage of development but you are encauraged to try it
+out and provide feedback.
 
-* Add constrained types (ie a string with a strict length, a number with a strict range etc.)
-* Benchmark against other libs and make sure it's fast enough
+For planned features check out [the issues](https://github.com/dryrb/dry-data/labels/feature).
 
 ## Development
 

data/dry-data.gemspec

@@ -27,7 +27,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency 'thread_safe', '~> 0.3'
   spec.add_runtime_dependency 'dry-container', '~> 0.2'
+  spec.add_runtime_dependency 'dry-configurable', '~> 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

@@ -4,6 +4,7 @@ require 'set'
 
 require 'dry-container'
 require 'inflecto'
+require 'thread_safe/cache'
 
 require 'dry/data/version'
 require 'dry/data/container'
@@ -13,6 +14,10 @@ require 'dry/data/dsl'
 
 module Dry
   module Data
+    extend Dry::Configurable
+
+    setting :namespace, self
+
     class SchemaError < TypeError
       def initialize(key, value)
         super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
@@ -26,9 +31,14 @@ module Dry
     end
 
     StructError = Class.new(TypeError)
+    ConstraintError = Class.new(TypeError)
 
     TYPE_SPEC_REGEX = %r[(.+)<(.+)>].freeze
 
+    def self.finalize
+      define_constants(config.namespace, container._container.keys)
+    end
+
     def self.container
       @container ||= Container.new
     end
@@ -45,7 +55,7 @@ module Dry
     end
 
     def self.[](name)
-      type_map.fetch(name) do
+      type_map.fetch_or_store(name) do
         result = name.match(TYPE_SPEC_REGEX)
 
         type =
@@ -60,13 +70,32 @@ module Dry
       end
     end
 
+    def self.define_constants(namespace, identifiers)
+      names = identifiers.map do |id|
+        parts = id.split('.')
+        [Inflecto.camelize(parts.pop), parts.map(&Inflecto.method(:camelize))]
+      end
+
+      names.map do |(klass, parts)|
+        mod = parts.reduce(namespace) do |a, e|
+          a.constants.include?(e.to_sym) ? a.const_get(e) : a.const_set(e, Module.new)
+        end
+
+        mod.const_set(klass, self[identifier((parts + [klass]).join('::'))])
+      end
+    end
+
+    def self.identifier(klass)
+      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 ||= {}
+      @type_map ||= ThreadSafe::Cache.new
     end
   end
 end

data/lib/dry/data/constraints.rb

@@ -0,0 +1,20 @@
+require 'dry-equalizer' # FIXME: this should not be needed
+
+require 'dry/validation/rule_compiler'
+require 'dry/validation/predicates'
+
+module Dry
+  module Data
+    def self.Rule(primitive, options)
+      rule_compiler.(
+        options.map { |key, val|
+          [:val, [primitive, [:predicate, [:"#{key}?", [val]]]]]
+        }
+      ).reduce(:and)
+    end
+
+    def self.rule_compiler
+      @rule_compiler ||= Validation::RuleCompiler.new(Validation::Predicates)
+    end
+  end
+end

data/lib/dry/data/type.rb

@@ -1,16 +1,37 @@
 require 'dry/data/type/optional'
 require 'dry/data/type/hash'
 require 'dry/data/type/array'
+require 'dry/data/type/enum'
 
 require 'dry/data/sum_type'
+require 'dry/data/constraints'
 
 module Dry
   module Data
     class Type
       attr_reader :constructor
-
       attr_reader :primitive
 
+      class Constrained < Type
+        attr_reader :rule
+
+        def initialize(constructor, primitive, rule)
+          super(constructor, primitive)
+          @rule = rule
+        end
+
+        def call(input)
+          result = super(input)
+
+          if rule.(result).success?
+            result
+          else
+            raise ConstraintError, "#{input.inspect} violates constraints"
+          end
+        end
+        alias_method :[], :call
+      end
+
       def self.[](primitive)
         if primitive == ::Array
           Type::Array
@@ -38,6 +59,14 @@ module Dry
         @primitive = primitive
       end
 
+      def constrained(options)
+        Constrained.new(constructor, primitive, Data.Rule(primitive, options))
+      end
+
+      def enum(*values)
+        Enum.new(values, constrained(inclusion: values))
+      end
+
       def name
         primitive.name
       end

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

@@ -0,0 +1,27 @@
+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

data/lib/dry/data/types.rb

@@ -11,6 +11,8 @@ module Dry
 
     NON_COERCIBLE = {
       nil: NilClass,
+      symbol: Symbol,
+      class: Class,
       true: TrueClass,
       false: FalseClass,
       date: Date,

data/lib/dry/data/version.rb

@@ -1,5 +1,5 @@
 module Dry
   module Data
-    VERSION = '0.2.1'.freeze
+    VERSION = '0.3.0'.freeze
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: dry-data
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-30 00:00:00.000000000 Z
+date: 2015-12-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: thread_safe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: dry-container
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  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
@@ -123,12 +151,14 @@ files:
 - lib/dry/data.rb
 - lib/dry/data/coercions/form.rb
 - lib/dry/data/compiler.rb
+- lib/dry/data/constraints.rb
 - lib/dry/data/container.rb
 - lib/dry/data/dsl.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/enum.rb
 - lib/dry/data/type/hash.rb
 - lib/dry/data/type/optional.rb
 - lib/dry/data/types.rb