foraneus 0.0.12 → 0.0.13

data/spec/lib/foraneus/converters/float_converter_spec.rb

@@ -2,43 +2,45 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Float do
 
+  subject { Foraneus::Converters::Float.new }
+
   describe '#parse' do
-    context 'with valid values' do
+    describe 'with valid values' do
       let(:number) { 1234.5678 }
       let(:raw_number) { number.to_s }
 
       it 'returns a float number' do
         parsed = subject.parse(raw_number)
 
-        parsed.should be_a(Float)
+        assert_kind_of Float, parsed
       end
 
       it 'parses the number' do
         parsed = subject.parse(raw_number)
 
-        parsed.should == number
+        assert_equal number, parsed
       end
 
-      context 'with big ones' do
+      describe 'with big ones' do
         let(:big_number) { (11 ** 20) + 0.33 }
         let(:raw_big_number) { big_number.to_s }
 
         it 'also returns a float number' do
           parsed = subject.parse(raw_big_number)
 
-          parsed.should be_a(Float)
+          assert_kind_of Float, parsed
         end
 
         it 'also parses the number' do
           parsed = subject.parse(raw_big_number)
 
-          parsed.should == big_number
+          assert_equal big_number, parsed
         end
       end
     end
 
-    context 'when separator and delimiter are given' do
-      subject(:converter) {
+    describe 'when separator and delimiter are given' do
+      let(:converter) {
         Foraneus::Converters::Float.new(:delimiter => '.', :separator => ',')
       }
 
@@ -46,35 +48,35 @@ describe Foraneus::Converters::Float do
         s = '1.234.567,89'
         n = 1_234_567.89
 
-        converter.parse(s).should eq(n)
+        assert_equal n, converter.parse(s)
       end
 
       it 'parses a float representation when no integer part' do
         s = ',56'
         n = 0.56
 
-        converter.parse(s).should eq(n)
+        assert_equal n, converter.parse(s)
       end
     end
 
-    context 'with invalid values' do
+    describe 'with invalid values' do
       let(:raw_invalid) { 'INVALID' }
 
       it 'raises an error' do
-        expect {
+        assert_raises(ArgumentError) {
           subject.parse(raw_invalid)
-        }.to raise_error
+        }
       end
     end
   end
 
   describe '#raw' do
     it 'returns a string representation' do
-      subject.raw(2.34).should eq('2.34')
+      assert_equal '2.34', subject.raw(2.34)
     end
 
-    context 'when separator and delimiter are given' do
-      subject(:converter) {
+    describe 'when separator and delimiter are given' do
+      let(:converter) {
         Foraneus::Converters::Float.new(:delimiter => '.', :separator => ',')
       }
 
@@ -82,28 +84,28 @@ describe Foraneus::Converters::Float do
         n = 1_234_567.89
         s = '1.234.567,89'
 
-        converter.raw(n).should eq(s)
+        assert_equal s, converter.raw(n)
       end
     end
 
-    context 'when precision is given' do
-      subject(:converter) {
+    describe 'when precision is given' do
+      let(:converter) {
         Foraneus::Converters::Float.new(:precision => 2)
       }
 
       it 'fills with zeros when value precision is smaller than converter precision' do
         n = 3.1
-        converter.raw(n).should eq('3.10')
+        assert_equal '3.10', converter.raw(n)
       end
 
       it 'does not affect the representation when precision and converter precision are both equal' do
         n = 3.14
-        converter.raw(n).should eq('3.14')
+        assert_equal '3.14', converter.raw(n)
       end
 
       it 'does not truncate the representation when precision is larger than converter precision' do
         n = 3.145
-        converter.raw(n).should eq('3.145')
+        assert_equal '3.145', converter.raw(n)
       end
     end
 

data/spec/lib/foraneus/converters/integer_converter_spec.rb

@@ -2,43 +2,46 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Integer do
 
+  let(:converter) { Foraneus::Converters::Integer.new }
+
   describe '#parse' do
-    context 'with valid values' do
+
+    describe 'with valid values' do
       let(:number) { 1234 }
       let(:raw_number) { number.to_s }
 
       it 'returns an integer number' do
-        parsed = subject.parse(raw_number)
+        parsed = converter.parse(raw_number)
 
-        parsed.should be_a(Integer)
+        assert_kind_of Integer, parsed
       end
 
       it 'parses the number' do
-        parsed = subject.parse(raw_number)
+        parsed = converter.parse(raw_number)
 
-        parsed.should == number
+        assert_equal number, parsed
       end
 
-      context 'with big ones' do
+      describe 'with big ones' do
         let(:big_number) { (11 ** 20) }
         let(:raw_big_number) { big_number.to_s }
 
         it 'also returns an integer' do
-          parsed = subject.parse(raw_big_number)
+          parsed = converter.parse(raw_big_number)
 
-          parsed.should be_a(Integer)
+          assert_kind_of Integer, parsed
         end
 
         it 'also parses the number' do
-          parsed = subject.parse(raw_big_number)
+          parsed = converter.parse(raw_big_number)
 
-          parsed.should == big_number
+          assert_equal big_number, parsed
         end
       end
     end
 
-    context 'when delimiter is given' do
-      subject(:converter) {
+    describe 'when delimiter is given' do
+      let(:converter) {
         Foraneus::Converters::Integer.new(:delimiter => '.')
       }
 
@@ -46,44 +49,44 @@ describe Foraneus::Converters::Integer do
         s = '1.234.567'
         n = 1_234_567
 
-        converter.parse(s).should eq(n)
+        assert_equal n, converter.parse(s)
       end
     end
 
-    context 'with invalid values' do
+    describe 'with invalid values' do
       let(:raw_invalid) { 'INVALID' }
 
       it 'raises an error' do
-        expect {
-          subject.parse(raw_invalid)
-        }.to raise_error
+        assert_raises(ArgumentError) {
+          converter.parse(raw_invalid)
+        }
       end
     end
 
-    context 'with empty values' do
+    describe 'with empty values' do
       it 'raises an error' do
-        expect {
-          subject.parse('')
-        }.to raise_error
+        assert_raises(ArgumentError) {
+          converter.parse('')
+        }
       end
     end
 
-    context 'with nil values' do
+    describe 'with nil values' do
       it 'raises an error' do
-        expect {
-          subject.parse(nil)
-        }.to raise_error
+        assert_raises(TypeError) {
+          converter.parse(nil)
+        }
       end
     end
   end
 
   describe '#raw' do
     it 'returns a string representation' do
-      subject.raw(2).should eq('2')
+      assert_equal('2', converter.raw(2))
     end
 
-    context 'when delimiter is given' do
-      subject(:converter) {
+    describe 'when delimiter is given' do
+      let(:converter) {
         Foraneus::Converters::Integer.new(:delimiter => '.')
       }
 
@@ -91,7 +94,7 @@ describe Foraneus::Converters::Integer do
         n = 1_234_567
         s = '1.234.567'
 
-        converter.raw(n).should eq(s)
+        assert_equal(s, converter.raw(n))
       end
     end
 

data/spec/lib/foraneus/converters/noop_converter_spec.rb

@@ -2,11 +2,13 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Noop do
 
+  let(:converter) { Foraneus::Converters::Noop.new }
+
   describe '#parse' do
     it 'returns the given object' do
       o = Object.new
 
-      subject.parse(o).should be(o)
+      assert_equal(o, converter.parse(o))
     end
   end
 
@@ -14,7 +16,7 @@ describe Foraneus::Converters::Noop do
     it 'returns the given object' do
       o = Object.new
 
-      subject.raw(o).should be(o)
+      assert_equal(o, converter.raw(o))
     end
   end
 end

data/spec/lib/foraneus/converters/string_converter_spec.rb

@@ -2,27 +2,29 @@ require 'spec_helper'
 
 describe Foraneus::Converters::String do
 
+  subject { Foraneus::Converters::String.new }
+
   describe '#parse' do
     it 'returns the string' do
       parsed = subject.parse('string')
 
-      parsed.should eq('string')
+      assert_equal 'string', parsed
     end
 
     it 'returns a string representation' do
       parsed = subject.parse(1)
 
-      parsed.should eq('1')
+      assert_equal '1', parsed
     end
   end
 
   describe '#raw' do
     it 'returns the string' do
-      subject.raw('a string').should eq('a string')
+      assert_equal 'string', subject.raw('string')
     end
 
     it 'returns a string representation' do
-      subject.raw(1).should eq('1')
+      assert_equal '1', subject.raw(1)
     end
   end
 end

data/spec/lib/foraneus_spec.rb

@@ -10,259 +10,350 @@ describe Foraneus do
     end
   }
 
-  describe '.parse' do
-    context 'with parseable data' do
-      subject(:form) { form_spec.parse(:delay => '5') }
-
-      its(:delay) { should eq(5) }
+  describe 'when errors accessor is renamed' do
+    let(:form_spec) {
+      Class.new(Foraneus) do
 
-      its(:data) { should include(:delay => 5) }
+        field :errors
 
-      its([:delay]) { should eq('5') }
+        accessors[:errors] = :non_clashing_errors
+      end
+    }
 
-      its(['delay']) { should be_nil }
+    describe 'a parsed form' do
+      let(:form) { form_spec.parse(:errors => 'errors') }
 
-      its([]) { should include(:delay => '5') }
+      it 'can return the errors field value' do
+        assert_equal 'errors', form.errors
+      end
 
-      it { should be_valid }
+      it 'can return the raw errors value' do
+        assert_equal 'errors', form[:errors]
+      end
 
-      its([:errors]) { should be_empty }
+      it 'responds to the new accessor' do
+        assert_equal({}, form.non_clashing_errors)
+      end
+    end
+  end
 
-      context 'when strings as keys' do
-        subject(:form) { form_spec.parse('delay' => '5') }
+  describe 'when data accessor is renamed' do
+    let(:form_spec) {
+      Class.new(Foraneus) do
 
-        its(['delay']) { should eq('5') }
+        field :delay
+        field :data
 
-        its([:delay]) { should eq('5') }
+        accessors[:data] = :non_clashing_data
+      end
+    }
 
-        its(:data) { should include('delay' => 5) }
+    describe 'a parsed form' do
+      let(:form) { form_spec.parse(:delay => 5, :data => 'value') }
 
-        its([]) { should include('delay' => '5') }
+      it 'can return the data field value' do
+        assert_equal 'value', form.data
       end
 
-      context 'when empty strings' do
-        let(:converter) { Foraneus::Converters::String.new }
+      it 'responds to the new accessor' do
+        assert_equal({:delay => 5, :data => 'value'}, form.non_clashing_data)
+      end
 
-        subject(:form) { form_spec.parse(:delay => '') }
+    end
 
-        its(:delay) { should eq(nil) }
+    describe 'when obtaining a raw representation' do
+      let(:form) { form_spec.raw(:delay => 5, :data => 'value') }
 
-        its(:data) { should include(:delay => nil) }
+      it 'allows access to the data field value' do
+        assert_equal 'value', form[:data]
+      end
 
-        it { should be_valid }
+      it 'allows access to whole data set' do
+        assert_equal({:delay => 5, :data => 'value'}, form[])
       end
     end
+  end
 
-    context 'with non parseable data' do
-      subject(:form) { form_spec.parse(:delay => 'FIVE') }
+  describe '.parse' do
+    describe 'with parseable data' do
+      subject { form_spec.parse(:delay => '5') }
 
-      its(:delay) { should be_nil }
+      it 'parses' do
 
-      its([:delay]) { should eq('FIVE') }
+        assert_equal 5, subject.delay
+        assert_equal 5, subject.data[:delay]
 
-      it { should_not be_valid }
+        assert_equal '5', subject[:delay]
+        assert_nil subject['delay']
+        assert_equal({ :delay => '5' }, subject[])
 
-      its([:errors]) { should include(:delay) }
+        assert subject.valid?
 
-      describe 'an error' do
-        subject(:error) { form[:errors].values.first }
+        assert_empty subject.errors
+      end
 
-        let(:converter_exception) do
-          begin
-            converter.parse('FIVE')
-          rescue
-            e = $!
-          end
+      describe 'when strings as keys' do
+        subject { form_spec.parse('delay' => '5') }
 
-          e
+        it 'parses given data' do
+          assert_equal '5', subject['delay']
+          assert_equal '5', subject[:delay]
+          assert_equal 5, subject.data['delay']
+
+          assert_equal({ 'delay' => '5' }, subject[])
         end
+      end
 
-        its(:key) { should eq(converter_exception.class.name) }
+      describe 'when empty strings' do
+        subject { form_spec.parse(:delay => '') }
 
-        its(:message) { should eq(converter_exception.message) }
-      end
-    end
+        it 'parses' do
+          assert_nil subject.delay
 
-    context 'with unexpected data' do
-      subject(:form) { form_spec.parse(:position => 'north') }
+          assert_nil subject.data[:delay]
 
-      it 'does not have a getter for the received param' do
-        expect {
-          form.position
-        }.to raise_error(NoMethodError)
+          assert subject.valid?
+        end
       end
 
-      its(:data) { should_not include(:position) }
+      describe 'with non parseable data' do
+        subject { form_spec.parse(:delay => 'FIVE') }
 
-      its([:position]) { should eq('north') }
+        it 'sets corresponding data as nil' do
+          assert_nil subject.delay
 
-      its([]) { should include(:position => 'north') }
+          assert_equal 'FIVE', subject[:delay]
 
-      it { should be_valid }
-    end
+          refute subject.valid?
 
-    context 'when a field is declared as blanks_as_nil = true' do
-      let(:converter) { Foraneus::Converters::String.new(:blanks_as_nil => true) }
+          assert_includes subject.errors, :delay
+        end
 
-      subject(:form) { form_spec.parse(:delay => '') }
+        describe 'an error' do
+          let(:error) { subject.errors.values.first }
 
-      its(:delay) { should be_nil }
+          let(:converter_exception) do
+            begin
+              converter.parse('FIVE')
+            rescue
+              e = $!
+            end
 
-      its(:data) { should include(:delay => nil) }
+            e
+          end
 
-      its([:delay]) { should eq('') }
+          it 'provides a key' do
+            assert_equal error.key, converter_exception.class.name
+          end
 
-      its([]) { should include(:delay => '') }
-    end
+          it 'provides a message' do
+            assert_equal error.message, converter_exception.message
+          end
+        end
+      end
 
-    context 'when a field is declared as blanks_as_nil = false' do
-      let(:converter) { Foraneus::Converters::String.new(:blanks_as_nil => false) }
+      describe 'with unexpected data' do
+        subject { form_spec.parse(:position => 'north') }
 
-      subject(:form) { form_spec.parse(:delay => '') }
+        it 'does not have a getter for the received param' do
+          assert_raises(NoMethodError) {
+            subject.position
+          }
+        end
 
-      its(:delay) { should eq('') }
+        it 'parses' do
+          refute_includes subject.data, :position
 
-      its(:data) { should include(:delay => '') }
-    end
+          assert_equal 'north', subject[:position]
 
-    shared_examples 'an absent parameters value handler' do |missing_value|
-      subject(:form) { form_spec.parse(:delay => missing_value) }
+          assert_equal 'north', subject[][:position]
 
-      it { should be_valid }
+          assert subject.valid?
+        end
+      end
 
-      its(:delay) { should be_nil }
+      describe 'when a field is declared as blanks_as_nil = true' do
+        let(:converter) { Foraneus::Converters::String.new(:blanks_as_nil => true) }
 
-      its(:data) { should include(:delay => nil) }
+        subject { form_spec.parse(:delay => '') }
 
-      its([:delay]) { should eq(missing_value) }
+        it 'parses' do
+          assert_nil subject.delay
 
-      its([]) { should include(:delay => missing_value) }
+          assert_equal({ :delay => nil }, subject.data)
+          assert_equal '', subject[:delay]
+          assert_equal({ :delay => '' }, subject[])
+        end
+      end
 
-      context 'when required field' do
-        let(:converter) { Foraneus::Converters::Integer.new(:required => true) }
+      describe 'when a field is declared as blanks_as_nil = false' do
+        let(:converter) { Foraneus::Converters::String.new(:blanks_as_nil => false) }
 
-        it { should_not be_valid }
+        subject { form_spec.parse(:delay => '') }
 
-        its(:delay) { should be_nil }
+        it 'parses' do
+          assert_equal '', subject.delay
+          assert_equal '', subject.data[:delay]
+        end
+      end
 
-        its(:data) { should_not include(:delay) }
+      an_absent_parameters_value_handler = ->(missing_value) do
+        subject { form_spec.parse(:delay => missing_value) }
 
-        its([:delay]) { should eq(missing_value) }
+        it 'parses' do
+          assert subject.valid?
 
-        its([]) { should include(:delay => missing_value) }
+          assert_nil subject.delay
 
-        its([:errors]) { should include(:delay) }
+          assert_equal missing_value, subject[:delay]
+          assert_equal missing_value, subject[][:delay]
+        end
 
-        describe 'an error' do
-          subject(:error) { form[:errors].values.first }
+        describe 'when required field' do
+          let(:converter) { Foraneus::Converters::Integer.new(:required => true) }
+
+          it 'parses' do
+            refute subject.valid?
+
+            assert_nil subject.delay
+
+            refute_includes subject.data, :delay
+
+            assert_equal missing_value, subject[][:delay]
 
-          its(:key) { should eq('KeyError') }
+            assert_includes subject.errors, :delay
+          end
+
+          describe 'an error' do
+            let(:error) { subject.errors.values.first }
+
+            it 'has key = KeyError' do
+              assert_equal 'KeyError', error.key
+            end
+          end
         end
       end
-    end
 
-    context 'with nil values' do
-      it_behaves_like 'an absent parameters value handler', nil
-    end
-
-    context 'with empty values' do
-      it_behaves_like 'an absent parameters value handler', ''
-    end
+      describe 'with nil values' do
+        instance_exec(nil, &an_absent_parameters_value_handler)
+      end
 
-    context 'when required field' do
-      let(:converter) { Foraneus::Converters::Integer.new(:required => true) }
+      describe 'with empty values' do
+        instance_exec('', &an_absent_parameters_value_handler)
+      end
 
-      context 'when missing input parameter' do
-        subject(:form) { form_spec.parse }
+      describe 'when required field' do
+        let(:converter) { Foraneus::Converters::Integer.new(:required => true) }
 
-        it { should_not be_valid }
+        describe 'when missing input parameter' do
+          subject { form_spec.parse }
 
-        its(:delay) { should be_nil }
+          it 'parses' do
+            refute subject.valid?
 
-        its([:delay]) { should be_nil }
+            assert_nil subject.delay
+            assert_nil subject[:delay]
+          end
+        end
       end
-    end
 
-    context 'when default value' do
-      let(:converter) { Foraneus::Converters::Integer.new(:default => 1) }
+      describe 'when default value' do
+        let(:converter) { Foraneus::Converters::Integer.new(:default => 1) }
 
-      subject(:form) { form_spec.parse }
+        subject { form_spec.parse }
 
-      it { should be_valid }
+        it 'parses' do
+          assert subject.valid?
 
-      its(:delay) { should eq(1) }
+          assert_equal 1, subject.delay
 
-      its(:data) { should include(:delay => 1) }
+          assert_equal 1, subject.data[:delay]
 
-      its([:delay]) { should be_nil}
+          assert_nil subject[:delay]
 
-      its([]) { should include(:delay => nil) }
+          assert_nil subject[][:delay]
 
-      its([:errors]) { should_not include(:delay) }
+          refute subject.errors.include?(:delay)
+        end
 
-      context 'when missing required field' do
-        let(:converter) { Foraneus::Converters::Integer.new(:default => 1, :required => true) }
+        describe 'when missing required field' do
+          let(:converter) { Foraneus::Converters::Integer.new(:default => 1, :required => true) }
 
-        subject(:form) { form_spec.parse }
+          subject { form_spec.parse }
 
-        it { should_not be_valid }
+          it 'parses' do
+            refute subject.valid?
 
-        its(:delay) { should be_nil }
+            assert_nil subject.delay
 
-        its([:delay]) { should be_nil }
+            assert_nil subject[:delay]
+          end
+        end
       end
     end
   end
 
   describe '.raw' do
-    subject(:form) { form_spec.raw(:delay => 5) }
+    subject { form_spec.raw(:delay => 5) }
 
-    its(:data) { should include(:delay => 5) }
+    it 'parses' do
+      assert_equal 5, subject.data[:delay]
 
-    its(:delay) { should eq(5) }
+      assert_equal 5, subject.delay
 
-    its([:delay]) { should eq('5') }
+      assert_equal '5', subject[:delay]
 
-    its([]) { should include(:delay => '5') }
+      assert_equal '5', subject[][:delay]
 
-    it { should be_valid }
+      assert subject.valid?
 
-    its([:errors]) { should be_empty }
+      assert_empty subject.errors
+    end
+
+    describe 'when strings as keys' do
+      subject { form_spec.raw('delay' => 5) }
 
-    context 'when strings as keys' do
-      subject(:form) { form_spec.raw('delay' => 5) }
+      it 'parses' do
+        assert_equal 5, subject.data['delay']
 
-      its(:data) { should include('delay' => 5) }
+        assert_equal '5', subject['delay']
 
-      its(['delay']) { should eq('5') }
+        assert_equal '5', subject[:delay]
 
-      its([:delay]) { should eq('5') }
+        assert_equal '5', subject[]['delay']
 
-      its([]) { should include('delay' => '5') }
+        assert subject.valid?
+
+        assert_empty subject.errors
+      end
     end
 
-    context 'with nil values' do
-      subject(:form) { form_spec.raw('delay' => nil) }
+    describe 'with nil values' do
+      subject { form_spec.raw('delay' => nil) }
 
-      its(:data) { should include('delay' => nil) }
+      it 'parses' do
+        assert_nil subject.data['delay']
 
-      its(['delay']) { should eq(nil) }
+        assert_nil subject['delay']
 
-      its([:delay]) { should eq(nil) }
+        assert_nil subject[:delay]
 
-      its([]) { should include('delay' => nil) }
+        assert_nil subject[]['delay']
+      end
     end
 
-    context 'when default value' do
+    describe 'when default value' do
       let(:converter) { Foraneus::Converters::Integer.new(:default => 1) }
 
-      subject(:form) { form_spec.raw }
-
-      its(:delay) { should be_nil }
+      subject { form_spec.raw }
 
-      its([:delay]) { should eq('1') }
+      it 'parses' do
+        assert_nil subject.delay
 
-      its([]) { should include(:delay => '1') }
+        assert_equal '1', subject[:delay]
+        assert_equal '1', subject[][:delay]
+      end
     end
   end
+
 end