lego 0.0.3

data/lib/lego/value/string.rb

@@ -0,0 +1,20 @@
+module Lego::Value
+  class String < Base
+
+    def parsers
+      [
+       ->(v) { v.respond_to?(:to_str) ? Lego.just(v.to_str) : Lego.fail("invalid string: '#{v}'") },
+       ->(v) { strip? ? Lego.just(v.strip) : Lego.just(v) },
+       ->(v) { (not allow_blank? and v.blank?) ? Lego.none : Lego.just(v) },
+      ]
+    end
+
+    def allow_blank?
+      @opts.fetch(:allow_blank, false)
+    end
+
+    def strip?
+      @opts.fetch(:strip, true)
+    end
+  end
+end

data/spec/lego/either/fail_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Lego::Either::Fail do
+
+  subject { Lego::Either::Fail.new(2) }
+
+  describe '#initialize' do
+
+    its(:error?) { should == true }
+    its(:none?)  { should == false }
+    its(:value?) { should == false }
+
+    its(:error)  { should == 2 }
+
+    it 'fails for :value' do
+      ->{ subject.value }.should raise_error(NoMethodError)
+    end
+
+    it 'defines shortcut' do
+      Lego.fail(1).should be_error(1)
+    end
+  end
+
+  describe '#next' do
+    let(:callable) do
+      ->(err) { fail 'Do not call me' }
+    end
+
+    it 'does not call callable' do
+      ->{ subject.next(callable) }.should_not raise_error
+    end
+
+    it 'returns self' do
+      subject.next(callable).should eql(subject)
+    end
+  end
+
+end

data/spec/lego/either/just_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Lego::Either::Just do
+
+  subject { Lego::Either::Just.new(2) }
+
+  describe '#initialize' do
+    its(:value?) { should == true }
+    its(:none?)  { should == false }
+    its(:error?) { should == false }
+
+    its(:value) { should == 2 }
+
+    it 'fails for :error' do
+      ->{ subject.error }.should raise_error(NoMethodError)
+    end
+
+    it 'defines shortcut' do
+      Lego.just(1).should be_value
+    end
+  end
+
+  describe '#next' do
+    it 'binds and calls callable' do
+      callable = ->(val) { fail "Call me - #{val}" }
+      ->{ subject.next(callable) }.should raise_error('Call me - 2')
+    end
+
+    it 'returns new Just' do
+      callable = ->(num) { Lego.just(num * 20) }
+      subject.next(callable).should be_just(40)
+    end
+
+    it 'returns None' do
+      callable = ->(num) { Lego.none }
+      subject.next(callable).should be_nothing
+    end
+
+    it 'returns Fail' do
+      callable = ->(num) { Lego.fail('oops') }
+      subject.next(callable).should be_error('oops')
+    end
+
+    it 'fails on not Eitherish return value' do
+      callable = ->(num) { 'a string' }
+      ->{ subject.next(callable) }.should raise_error(TypeError, /Not Lego::Either/)
+    end
+  end
+
+end

data/spec/lego/either/none_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Lego::Either::None do
+
+  subject { Lego::Either::None.new }
+
+  its(:none?)  { should == true }
+  its(:value?) { should == false }
+  its(:error?) { should == false }
+
+  it 'fails for :value' do
+    ->{ subject.value }.should raise_error(NoMethodError)
+  end
+
+  it 'fails for :error' do
+    ->{ subject.error }.should raise_error(NoMethodError)
+  end
+
+  it 'defines shortcut' do
+    Lego.none.should be_none
+  end
+
+  describe '#next' do
+    let(:callable) do
+      ->(err) { fail 'Do not call me!' }
+    end
+
+    it 'does not call callable' do
+      ->{ subject.next(callable) }.should_not raise_error
+    end
+
+    it 'returns self' do
+      subject.next(callable).should eql(subject)
+    end
+  end
+
+end

data/spec/lego/model_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Lego::Model do
+
+  class Person < Lego::Model
+    attribute :name, :string
+    attribute :age,  :integer
+  end
+
+  class Family < Lego::Model
+    attribute :last_name, :string
+    attribute :father, Person
+  end
+
+  context 'Person' do
+    subject do
+      Person.new(name: 'Alice', age: '10')
+    end
+
+    it '::attributes' do
+      Person.attribute_names.should == [:name, :age]
+    end
+
+    its(:name){ should == 'Alice' }
+    its(:age){ should == 10 }
+
+    it '#attributes' do
+      subject.attributes.should == { name: 'Alice', age: 10 }
+      subject.attributes.should be_frozen
+    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}")
+    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/)
+    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')
+    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')
+    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
+    end
+  end
+
+  context 'Family' do
+    it 'creates recursively from hash' do
+      family = Family.new(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')
+    end
+
+    it 'creates from partial hash' do
+      family = Family.new(last_name: 'Kowalski', father: Person.new(name: 'Bob', age: '55'))
+      family.should be_instance_of(Family)
+      family.last_name.should == 'Kowalski'
+      family.father.should == Person.new(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.as_json.should == {
+        :last_name => "Kowalski",
+        :father => {
+          :name => "Bob",
+          :age => 55
+        }
+      }
+    end
+
+  end
+
+end

data/spec/lego/value/base_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Lego::Value::Base do
+  let(:opts) { {} }
+
+  subject { Lego::Value::Base.new(opts) }
+
+  describe '#parse' do
+    context 'nil' do
+      specify { subject.parse(nil).should be_nothing }
+    end
+  end
+
+end

data/spec/lego/value/boolean_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Lego::Value::Boolean do
+
+  describe '#parse' do
+    context 'nil' do
+      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse('').should be_nothing }
+    end
+
+    context 'boolean string' do
+      specify { subject.parse('true').should be_just(true) }
+      specify { subject.parse('false').should be_just(false) }
+    end
+
+    context 'boolean value' do
+      specify { subject.parse(true).should be_just(true) }
+      specify { subject.parse(false).should be_just(false) }
+    end
+
+    context 'invalid value' do
+      specify { subject.parse('wtf').should be_error("invalid boolean: 'wtf'") }
+      specify { subject.parse('   ').should be_error("invalid boolean: '   '") }
+      specify { subject.parse(0).should be_error("invalid boolean: '0'") }
+    end
+  end
+
+  describe '#coerce' do
+    context 'nothing' do
+      context 'default' do
+        it 'raises error' do
+          expect{ subject.coerce(nil) }.to raise_error(Lego::CoerceError, 'missing value')
+          expect{ subject.coerce('') }.to raise_error(Lego::CoerceError, 'missing value')
+        end
+      end
+
+      context 'default handler -> false' do
+        subject { Lego::Value::Boolean.new(default: ->{ false }) }
+        specify { subject.coerce(nil).should == false }
+        specify { subject.coerce('').should == false }
+        specify { subject.coerce(true).should == true }
+      end
+
+      context 'default handler -> true' do
+        subject { Lego::Value::Boolean.new(default: ->{ true }) }
+        specify { subject.coerce(nil).should == true }
+        specify { subject.coerce('').should == true }
+        specify { subject.coerce(false).should == false }
+      end
+    end
+
+    context 'failure' do
+      it 'raises error' do
+        expect{ subject.coerce(123) }.to raise_error(Lego::CoerceError, "invalid boolean: '123'")
+      end
+    end
+
+    context 'success' do
+      specify { subject.coerce(true).should == true }
+    end
+  end
+end

data/spec/lego/value/date_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Lego::Value::Date do
+
+  describe '#parse' do
+    subject { Lego::Value::Date.new }
+
+    context 'nil' do
+      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse('').should be_nothing }
+    end
+
+    context 'invalid date' do
+      specify { subject.parse(123).should be_error("invalid date: '123'") }
+      specify { subject.parse('2012-02').should be_error("invalid date: '2012-02'") }
+    end
+
+    it 'parses date' do
+      subject.parse(Date.new(2012, 02, 01)).should be_just(Date.new(2012, 02, 01))
+    end
+
+    it 'parses time' do
+      subject.parse(Time.new(2012, 02, 01, 8, 30)).should be_just(Date.new(2012, 02, 01))
+    end
+
+    it 'parses string date' do
+      subject.parse('2012-02-01').should be_just(Date.new(2012, 02, 01))
+    end
+
+    it 'parses string time' do
+      subject.parse('2012-02-01T08:30:00Z').should be_just(Date.new(2012, 02, 01))
+    end
+  end
+
+  describe '#coerce' do
+    context 'nothing' do
+      context 'default' do
+        it 'raises error' do
+          expect{ subject.coerce(nil) }.to raise_error(Lego::CoerceError, 'missing value')
+          expect{ subject.coerce('') }.to raise_error(Lego::CoerceError, 'missing value')
+        end
+      end
+
+      context 'with :default handler' do
+        subject { Lego::Value::String.new(default: handler) }
+
+        context 'nil handler' do
+          let(:handler) { ->{ nil } }
+          specify { subject.coerce(nil).should be_nil }
+        end
+
+        context 'lambda handler' do
+          let(:handler) { proc{ Date.new(2000, 1, 1) } }
+          specify { subject.coerce('').should == Date.new(2000, 1, 1) }
+        end
+      end
+    end
+
+    context 'failure' do
+      it 'raises error' do
+        expect{ subject.coerce(123) }.to raise_error(Lego::CoerceError, "invalid date: '123'")
+      end
+    end
+
+    context 'success' do
+      it 'returns date' do
+        subject.coerce(Date.new(2012, 02, 01)).should == Date.new(2012, 02, 01)
+      end
+    end
+  end
+end

data/spec/lego/value/float_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Lego::Value::Float do
+
+  describe '#parse' do
+    subject { Lego::Value::Float.new(opts) }
+
+    let(:opts){ {} }
+
+    context 'nil' do
+      specify { subject.parse(nil).should be_nothing }
+      specify { subject.parse('').should be_nothing }
+    end
+
+    context 'invalid float' do
+      specify { subject.parse('  ').should be_error("invalid float: '  '") }
+      specify { subject.parse('2012-02').should be_error("invalid float: '2012-02'") }
+      specify { subject.parse('invalid').should be_error("invalid float: 'invalid'") }
+    end
+
+    it 'parses integer as float' do
+      subject.parse(123).should be_just(123.0)
+    end
+
+    it 'parses float' do
+      subject.parse(123.12).should be_just(123.12)
+    end
+
+    it 'parses string integer as float' do
+      subject.parse('-134').should be_just(-134.0)
+    end
+
+    it 'parses string float' do
+      subject.parse('-134.11').should be_just(-134.11)
+    end
+
+    context 'minimum' do
+      let(:opts){ { min: 4 } }
+      specify { subject.parse(4).should be_just(4) }
+      specify { subject.parse(3.99999).should be_error("less than minimum of 4: '3.99999'") }
+    end
+
+    context 'maximum' do
+      let(:opts){ { max: 4 } }
+      specify { subject.parse(4).should be_just(4) }
+      specify { subject.parse(4.01).should be_error("more than maximum of 4: '4.01'") }
+    end
+
+    context 'minimium and maximum' do
+      let(:opts){ { min: 0, max: 4 } }
+      specify { subject.parse(1.1).should be_just(1.1) }
+      specify { subject.parse(-0.1).should be_error("less than minimum of 0: '-0.1'") }
+      specify { subject.parse(4.1).should be_error("more than maximum of 4: '4.1'") }
+    end
+  end
+
+  describe '#coerce' do
+    context 'nothing' do
+      context 'default' do
+        it 'raises error' do
+          expect{ subject.coerce(nil) }.to raise_error(Lego::CoerceError, 'missing value')
+          expect{ subject.coerce('') }.to raise_error(Lego::CoerceError, 'missing value')
+        end
+      end
+
+      context 'with :default handler' do
+        subject { Lego::Value::Float.new(default: handler) }
+
+        context 'nil handler' do
+          let(:handler) { ->{ nil } }
+          specify { subject.coerce(nil).should be_nil }
+        end
+
+        context 'lambda handler' do
+          let(:handler) { ->{ 42.0 } }
+          specify { subject.coerce('').should == 42.0 }
+        end
+      end
+    end
+
+    context 'failure' do
+      it 'raises error' do
+        expect{ subject.coerce('foo') }.to raise_error(Lego::CoerceError, "invalid float: 'foo'")
+      end
+    end
+
+    context 'success' do
+      it 'returns float' do
+        subject.coerce('42').should == 42.0
+      end
+    end
+  end
+end