lego 0.0.4 → 0.0.5

data/lego.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "lego"
   gem.require_paths = ["lib"]
-  gem.version       = '0.0.4'
+  gem.version       = '0.0.5'
 
   gem.add_dependency 'activesupport'
 

data/lib/lego/model.rb

@@ -2,6 +2,17 @@ require 'active_support/core_ext/hash/deep_merge'
 
 module Lego
   class Model
+    class ParseError < StandardError
+      def initialize(errors={})
+        @errors = errors
+        super(errors.inspect)
+      end
+
+      attr_reader :errors
+    end
+
+    private_class_method :new
+
     class << self
 
       def attribute(attr, type, *args)
@@ -12,48 +23,99 @@ module Lego
         @_parsers ||= {}
       end
 
+      def validations
+        @_validations ||= Hash.new { |h,k| h[k] = [] }
+      end
+
       def attribute_names
         parsers.keys
       end
-    end
 
-    def initialize(attrs={})
-      fail ArgumentError, "attrs must be hash: '#{attrs.inspect}'" unless attrs.respond_to?(:key?)
-      attrs = attrs.dup
-      @attributes = {}.tap do |h|
-        self.class.parsers.each do |name, parser|
-          name = name.to_sym
-          value = attrs.key?(name) ? attrs.delete(name) : attrs.delete(name.to_s)
-          begin
-            h[name] = parser.coerce(value)
-          rescue Lego::CoerceError => e
-            fail ArgumentError, ":#{name} => #{e.message}"
+      def validates(attr, callable=nil, &block)
+        attr = attr.to_sym
+        if callable && callable.is_a?(Symbol)
+          validations[attr] << callable
+        else
+          validations[attr] << block
+        end
+      end
+
+      def coerce(hash)
+        res = parse(hash)
+        res.value? ? res.value : fail(ParseError.new(res.error))
+      end
+
+      def parse(hash)
+        return Lego.just(hash) if hash.instance_of?(self)
+
+        fail ArgumentError, "attrs must be hash: '#{hash.inspect}'" unless hash.respond_to?(:key?)
+
+        result = _parse(hash)
+
+        if result.value?
+          model = new(result.value)
+          _validate(model)
+        else
+          result
+        end
+      end
+
+      def _validate(obj)
+        attrs = {}
+        validations.each do |name, attr_validations|
+          attrs[name] = Lego.just(obj)
+          attr_validations.each do |validation|
+            if validation.is_a?(Symbol)
+              callable_method_name = validation.to_sym
+              validation = ->(o){ o.method(callable_method_name).call }
+            end
+            attrs[name] = attrs[name].next(validation)
           end
         end
-      end.freeze
-      fail ArgumentError, "Unknown attributes: #{attrs}" unless attrs.empty?
+
+        if attrs.all?{ |k,v| v.value? }
+          Lego.just(obj)
+        else
+          Lego.fail(Hash[*attrs.map{ |k,v| [k, v.error] if v.error? }.compact.flatten(1)])
+        end
+      end
+
+      def _parse(data)
+        data = data.dup
+
+        attrs = {}
+
+        parsers.each do |name, parser|
+          name = name.to_sym
+          value = data.key?(name) ? data.delete(name) : data.delete(name.to_s)
+
+          attrs[name] = parser.parse(value)
+        end
+
+        fail ArgumentError, "Unknown attributes: #{data}" unless data.empty?
+
+        if attrs.all?{ |k,v| v.value? }
+          Lego.just(Hash[*attrs.map{ |k,v| [k, v.value] }.flatten(1)])
+        else
+          Lego.fail(Hash[*attrs.map{ |k,v| [k, v.error] if v.error? }.compact.flatten(1)])
+        end
+      end
+    end
+
+    def initialize(attrs={})
+      @attributes = attrs.freeze
     end
 
     attr_reader :attributes
 
     def merge(other)
-      self.class.new(as_json.deep_merge(other))
+      self.class.coerce(as_json.deep_merge(other))
     end
 
     def method_missing(name, *args, &block)
       attributes.fetch(name.to_sym) { super }
     end
 
-    def self.coerce(hash)
-      hash.instance_of?(self) ? hash : self.new(hash)
-    end
-
-    def self.parse(hash)
-      Lego.just(self.coerce(hash))
-    rescue Lego::CoerceError => e
-      Lego.fail(e.message)
-    end
-
     # Equality
 
     def ==(o)

data/lib/lego/value.rb

@@ -6,6 +6,8 @@ module Lego
   end
 end
 
+class Boolean; end
+
 require_relative 'value/base'
 require_relative 'value/set'
 require_relative 'value/array'

data/lib/lego/value/base.rb

@@ -1,5 +1,6 @@
 module Lego::Value
   class Base
+
     def initialize(opts={})
       @opts = opts
     end
@@ -10,22 +11,21 @@ module Lego::Value
       parsers.each do |callable|
         val = val.next(callable)
       end
-      val
-    end
 
-    def coerce(val)
-      resp = parse(val)
-      if resp.value?
-        resp.value
-      elsif resp.error?
-        raise Lego::CoerceError, resp.error
-      elsif @opts[:default]
-        @opts[:default].call
+      return val unless val.none?
+
+      if @opts[:default]
+        Lego.just(@opts[:default].call)
       else
-        raise Lego::CoerceError, 'missing value'
+        Lego.fail('missing value')
       end
     end
 
+    def coerce(val)
+      res = parse(val)
+      res.value? ? res.value : fail(Lego::CoerceError, res.error)
+    end
+
     def parsers
       []
     end

data/spec/lego/model_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'date'
 
 describe Lego::Model do
 
@@ -14,7 +15,7 @@ describe Lego::Model do
 
   context 'Person' do
     subject do
-      Person.new(name: 'Alice', age: '10')
+      Person.coerce(name: 'Alice', age: '10')
     end
 
     it '::attributes' do
@@ -30,72 +31,80 @@ describe Lego::Model do
     end
 
     it 'raises error on unknown attribute' do
-      expect{ Person.new(name: 'Alice', age: '10', grade: 5) }.to raise_error(ArgumentError, "Unknown attributes: {:grade=>5}")
+      expect{ Person.coerce(name: 'Alice', age: '10', grade: 5) }.to raise_error(ArgumentError, "Unknown attributes: {:grade=>5}")
     end
 
     it 'fails on validation' do
-      expect{ Person.new(name: 'Alice') }.to raise_error(ArgumentError, ":age => missing value")
-      expect{ Person.new(name: 'Alice', age: Date.today) }.to raise_error(ArgumentError, /invalid integer/)
+      expect{ Person.coerce(name: 'Alice') }.to raise_error(Lego::Model::ParseError, '{:age=>"missing value"}')
+      expect{ Person.coerce(name: 'Alice', age: Date.today) }.to raise_error(Lego::Model::ParseError, /invalid integer/)
+    end
+
+    it 'stores errors as hash' do
+      begin
+        Person.coerce(name: 'Alice')
+      rescue => e
+        e.errors.should == { age: 'missing value' }
+      end
     end
 
     it 'fails on non-hash initialize' do
-      expect{ Person.new(nil) }.to raise_error(ArgumentError, "attrs must be hash: 'nil'")
+      expect{ Person.coerce(nil) }.to raise_error(ArgumentError, "attrs must be hash: 'nil'")
     end
 
     it 'dupes attributes' do
       h = { name: 'Alice', age: 10 }
-      Person.new(h)
+      Person.coerce(h)
       h.should == { name: 'Alice', age: 10 }
     end
   end
 
   context 'equality' do
     it '#==' do
-      Person.new(name: 'Alice', age: 10).should == Person.new(name: 'Alice', age: '10')
-      Person.new(name: 'Alice', age: 10).should_not == Person.new(name: 'Bob', age: '10')
-      Person.new(name: 'Alice', age: 10).should_not == Person.new(name: 'Alice', age: '12')
+      Person.coerce(name: 'Alice', age: 10).should == Person.coerce(name: 'Alice', age: '10')
+      Person.coerce(name: 'Alice', age: 10).should_not == Person.coerce(name: 'Bob', age: '10')
+      Person.coerce(name: 'Alice', age: 10).should_not == Person.coerce(name: 'Alice', age: '12')
     end
 
     it '#eql?' do
-      Person.new(name: 'Alice', age: 10).should eql Person.new(name: 'Alice', age: '10')
-      Person.new(name: 'Alice', age: 10).should_not eql Person.new(name: 'Bob', age: '10')
-      Person.new(name: 'Alice', age: 10).should_not eql Person.new(name: 'Alice', age: '12')
+      Person.coerce(name: 'Alice', age: 10).should eql Person.coerce(name: 'Alice', age: '10')
+      Person.coerce(name: 'Alice', age: 10).should_not eql Person.coerce(name: 'Bob', age: '10')
+      Person.coerce(name: 'Alice', age: 10).should_not eql Person.coerce(name: 'Alice', age: '12')
     end
 
     it '#hash' do
-      Person.new(name: 'Alice', age: 10).hash.should == Person.new(name: 'Alice', age: '10').hash
-      Person.new(name: 'Alice', age: 10).hash.should_not == Person.new(name: 'Bob', age: '10').hash
-      Person.new(name: 'Alice', age: 10).hash.should_not == Person.new(name: 'Alice', age: '12').hash
+      Person.coerce(name: 'Alice', age: 10).hash.should == Person.coerce(name: 'Alice', age: '10').hash
+      Person.coerce(name: 'Alice', age: 10).hash.should_not == Person.coerce(name: 'Bob', age: '10').hash
+      Person.coerce(name: 'Alice', age: 10).hash.should_not == Person.coerce(name: 'Alice', age: '12').hash
     end
   end
 
   context 'Family' do
     it 'creates recursively from hash' do
-      family = Family.new(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
+      family = Family.coerce(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
       family.should be_instance_of(Family)
       family.last_name.should == 'Kowalski'
-      family.father.should == Person.new(name: 'Bob', age: '55')
+      family.father.should == Person.coerce(name: 'Bob', age: '55')
     end
 
     it 'creates from partial hash' do
-      family = Family.new(last_name: 'Kowalski', father: Person.new(name: 'Bob', age: '55'))
+      family = Family.coerce(last_name: 'Kowalski', father: Person.coerce(name: 'Bob', age: '55'))
       family.should be_instance_of(Family)
       family.last_name.should == 'Kowalski'
-      family.father.should == Person.new(name: 'Bob', age: '55')
+      family.father.should == Person.coerce(name: 'Bob', age: '55')
     end
 
     it 'initializes from string keys' do
-      family = Family.new('last_name' => 'Kowalski', 'father' => Person.new('name' => 'Bob', 'age' => '55'))
+      family = Family.coerce('last_name' => 'Kowalski', 'father' => Person.coerce('name' => 'Bob', 'age' => '55'))
       family.should be_instance_of(Family)
       family.last_name.should == 'Kowalski'
-      family.father.should == Person.new(name: 'Bob', age: '55')
+      family.father.should == Person.coerce(name: 'Bob', age: '55')
     end
   end
 
 
   describe '#as_json' do
     it 'serializes Family' do
-      family = Family.new(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
+      family = Family.coerce(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
       family.as_json.should == {
         :last_name => "Kowalski",
         :father => {
@@ -107,7 +116,7 @@ describe Lego::Model do
   end
 
   describe '#merge' do
-    let(:one) { Family.new(last_name: 'Kowalski', father: { name: 'Bob', age: '55' }) }
+    let(:one) { Family.coerce(last_name: 'Kowalski', father: { name: 'Bob', age: '55' }) }
 
     it 'returns new object' do
       two = one.merge({})
@@ -118,9 +127,84 @@ describe Lego::Model do
     it 'merges changes' do
       two = one.merge(last_name: 'Tesla', father: { name: 'Nikola' })
 
-      one.should == Family.new(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
-      two.should == Family.new(last_name: 'Tesla', father: { name: 'Nikola', age: '55' })
+      one.should == Family.coerce(last_name: 'Kowalski', father: { name: 'Bob', age: '55' })
+      two.should == Family.coerce(last_name: 'Tesla', father: { name: 'Nikola', age: '55' })
+    end
+  end
+
+  describe '::validates' do
+    let(:today) { Date.today }
+
+    it 'runs validations after coercions' do
+      klass = Class.new(Lego::Model) do
+        attribute :start, Date
+        attribute :stop, Date
+
+        validates :start do |o| o.start < o.stop ? Lego.just(o) : Lego.fail('must start before end') end
+      end
+
+      klass.parse(start: today.to_s, stop: today).should be_error({start: 'must start before end'})
+    end
+
+    it 'validates via block' do
+      klass = Class.new(Lego::Model) do
+        attribute :start, Date
+        attribute :stop, Date
+
+        validates :start do |o| o.start < o.stop ? Lego.just(o) : Lego.fail('must start before end') end
+        validates :start do |o| (o.start + 2) < o.stop ? Lego.just(o) : Lego.fail('at least 3 days after') end
+      end
+
+      klass.parse(start: today.to_s, stop: today.to_s).should be_error(start: 'must start before end')
+      klass.parse(start: today.to_s, stop: (today + 2).to_s).should be_error(start: 'at least 3 days after')
+      klass.parse(start: today.to_s, stop: (today + 3).to_s).should be_value
+    end
+
+
+    it 'validates until first error in each attribute' do
+      klass = Class.new(Lego::Model) do
+        attribute :start, Date
+        attribute :stop, Date
+
+        validates :start do |o| o.start < o.stop ? Lego.just(o) : Lego.fail('must start before end') end
+        validates :start do |o| fail 'Should NOT EXECUTE' end
+        validates :stop  do |o| o.stop > o.start + 1 ? Lego.just(o) : Lego.fail('must stop after at least 3 days') end
+      end
+
+      klass.parse(start: today, stop: today).should be_error(start: 'must start before end', stop: 'must stop after at least 3 days')
+    end
+
+
+    it 'validates via instance method' do
+      klass = Class.new(Lego::Model) do
+        attribute :start, Date
+        attribute :stop, Date
+
+        validates :start, :check_start_before_end
+        validates :start, :check_at_least_3_days
+
+        def check_start_before_end
+          start < stop ? Lego.just(self) : Lego.fail('must start before end')
+        end
+
+        def check_at_least_3_days
+          (start + 2) < stop ? Lego.just(self) : Lego.fail('at least 3 days after')
+        end
+      end
+
+      klass.parse(start: today.to_s, stop: today.to_s).should be_error(start: 'must start before end')
+      klass.parse(start: today.to_s, stop: (today + 2).to_s).should be_error(start: 'at least 3 days after')
+      klass.parse(start: today.to_s, stop: (today + 3).to_s).should be_value
     end
   end
 
+  it 'correctly handles array values' do
+    klass = Class.new(Lego::Model) do
+      attribute :nums, Array, Integer, length: 2
+    end
+
+    klass.parse(nums: [1,2]).should be_value
+    klass.parse(nums: [1,2,3,4]).should be_error(nums: "length not 2: '[1, 2, 3, 4]'")
+  end
+
 end

data/spec/lego/value/array_spec.rb

@@ -6,7 +6,8 @@ describe Lego::Value::Array do
 
   describe '#parse' do
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
+      subject { Lego::Value::Array.new(String, allow_empty: false, default: ->{ 'DEFAULT' }) }
+      specify { subject.parse(nil).should be_just('DEFAULT') }
     end
 
     context 'invalid array or item' do
@@ -25,8 +26,8 @@ describe Lego::Value::Array do
     end
 
     context 'disallow empty' do
-      subject { Lego::Value::Array.new(String, allow_empty: false) }
-      specify { subject.parse([]).should be_nothing }
+      subject { Lego::Value::Array.new(String, allow_empty: false, default: ->{ 'DEFAULT' }) }
+      specify { subject.parse([]).should be_just('DEFAULT') }
     end
 
     context 'check length' do

data/spec/lego/value/base_spec.rb

@@ -6,9 +6,17 @@ describe Lego::Value::Base do
   subject { Lego::Value::Base.new(opts) }
 
   describe '#parse' do
-    context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
+    context 'nil is missing' do
+      context 'with default handler' do
+        let(:opts) { { default: ->{ 'default' } } }
+        specify { subject.parse(nil).should be_just('default') }
+      end
+
+      context 'without default handler' do
+        specify { subject.parse(nil).should be_error('missing value') }
+      end
     end
+
   end
 
 end

data/spec/lego/value/boolean_spec.rb

@@ -4,8 +4,10 @@ describe Lego::Value::Boolean do
 
   describe '#parse' do
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
-      specify { subject.parse('').should be_nothing }
+      subject { Lego::Value::Boolean.new(default: ->{ 'DEFAULT' }) }
+
+      specify { subject.parse(nil).should be_just('DEFAULT') }
+      specify { subject.parse('').should be_just('DEFAULT') }
     end
 
     context 'boolean string' do

data/spec/lego/value/date_spec.rb

@@ -6,8 +6,10 @@ describe Lego::Value::Date do
     subject { Lego::Value::Date.new }
 
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
-      specify { subject.parse('').should be_nothing }
+      subject { Lego::Value::Date.new(default: ->{ 'DEFAULT' }) }
+
+      specify { subject.parse(nil).should be_just('DEFAULT') }
+      specify { subject.parse('').should be_just('DEFAULT') }
     end
 
     context 'invalid date' do

data/spec/lego/value/float_spec.rb

@@ -8,8 +8,10 @@ describe Lego::Value::Float do
     let(:opts){ {} }
 
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
-      specify { subject.parse('').should be_nothing }
+      let(:opts){ {default: ->{ 42.0 } } }
+
+      specify { subject.parse(nil).should be_just(42.0) }
+      specify { subject.parse('').should be_just(42.0) }
     end
 
     context 'invalid float' do

data/spec/lego/value/integer_spec.rb

@@ -8,8 +8,10 @@ describe Lego::Value::Integer do
     let(:opts){ {} }
 
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
-      specify { subject.parse('').should be_nothing }
+      let(:opts){ {default: ->{ 42 } } }
+
+      specify { subject.parse(nil).should be_just(42) }
+      specify { subject.parse('').should be_just(42) }
     end
 
     context 'invalid integer' do

data/spec/lego/value/set_spec.rb

@@ -6,11 +6,11 @@ describe Lego::Value::Set do
     Array(elem).to_set
   end
 
-  subject { Lego::Value::Set.new(String) }
+  subject { Lego::Value::Set.new(String, default: ->{ 'DEFAULT' } ) }
 
   describe '#parse' do
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse(nil).should be_just('DEFAULT') }
     end
 
     context 'invalid set or item' do
@@ -33,12 +33,14 @@ describe Lego::Value::Set do
     end
 
     context 'disallow empty' do
-      subject { Lego::Value::Set.new(String, allow_empty: false) }
-      specify { subject.parse([]).should be_nothing }
+      subject { Lego::Value::Set.new(String, allow_empty: false, default: ->{ 'DEFAULT' }) }
+      specify { subject.parse([]).should be_just('DEFAULT') }
     end
   end
 
   describe '#coerce' do
+    subject { Lego::Value::Set.new(String) }
+
     context 'missing' do
       it 'raises error' do
         expect{ subject.coerce(nil) }.to raise_error(Lego::CoerceError, 'missing value')

data/spec/lego/value/string_spec.rb

@@ -11,12 +11,13 @@ describe Lego::Value::String do
     let(:opts) do
       {
         allow_blank: allow_blank,
-        strip: strip
+        strip: strip,
+        default: ->{ 'DEFAULT' }
       }
     end
 
     context 'nil' do
-      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse(nil).should be_just('DEFAULT') }
     end
 
     context 'not a string' do
@@ -46,21 +47,21 @@ describe Lego::Value::String do
 
       context 'strip' do
         let(:strip) { true }
-        specify { subject.parse('').should be_nothing }
-        specify { subject.parse('   ').should be_nothing }
+        specify { subject.parse('').should be_just('DEFAULT') }
+        specify { subject.parse('   ').should be_just('DEFAULT') }
       end
 
       context 'no strip' do
         let(:strip) { false }
-        specify { subject.parse('').should be_nothing }
-        specify { subject.parse('   ').should be_nothing }
+        specify { subject.parse('').should be_just('DEFAULT') }
+        specify { subject.parse('   ').should be_just('DEFAULT') }
       end
     end
 
     context 'matches' do
       subject { Lego::Value::String.new(opts.merge(matches: /^[A-Z]{3}$/)) }
 
-      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse(nil).should be_just('DEFAULT') }
       specify { subject.parse(123).should be_error("invalid string: '123'") }
 
       specify { subject.parse('abc').should be_error("does not match (/^[A-Z]{3}$/): 'abc'") }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lego
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-18 00:00:00.000000000 Z
+date: 2013-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -113,7 +113,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3608539237903599197
+      hash: 3624199644753223561
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -122,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3608539237903599197
+      hash: 3624199644753223561
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23