vedeu 0.6.7 → 0.6.8

data/test/lib/vedeu/models/page_test.rb

@@ -2,234 +2,241 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Page do
+  module Models
 
-    let(:described) { Vedeu::Page }
-    let(:instance)  { described.new(rows) }
-    let(:rows)      {
-      [
-        [:hydrogen, :helium, :lithium],
-        [:beryllium, :boron, :carbon],
-        [:nitrogen, :oxygen, :fluorine],
-      ]
-    }
+    describe Page do
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
+      let(:described) { Vedeu::Models::Page }
+      let(:instance)  { described.new(rows) }
+      let(:rows)      {
+        [
+          [:hydrogen, :helium, :lithium],
+          [:beryllium, :boron, :carbon],
+          [:nitrogen, :oxygen, :fluorine],
+        ]
+      }
 
-      context 'when there are no rows' do
-        let(:rows) {}
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
 
-        it { instance.instance_variable_get('@rows').must_equal([]) }
-      end
-
-      context 'when there are rows' do
-        it { instance.instance_variable_get('@rows').must_equal(rows) }
-      end
-    end
+        context 'when there are no rows' do
+          let(:rows) {}
 
-    describe '.coerce' do
-      let(:_value) {}
+          it { instance.instance_variable_get('@rows').must_equal([]) }
+        end
 
-      subject { described.coerce(_value) }
+        context 'when there are rows' do
+          it { instance.instance_variable_get('@rows').must_equal(rows) }
+        end
+      end
 
-      it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+      describe '.coerce' do
+        let(:_value) {}
 
-      context 'when the value is a Vedeu::Page' do
-        let(:_value) { Vedeu::Page.new }
+        subject { described.coerce(_value) }
 
-        it { subject.must_equal(_value) }
-      end
+        it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
 
-      context 'when the value is a Vedeu::Row' do
-        let(:_value)   { Vedeu::Row.new }
-        let(:expected) { Vedeu::Page.new([_value]) }
+        context 'when the value is a Vedeu::Models::Page' do
+          let(:_value) { described.new }
 
-        it { subject.must_equal(expected) }
-      end
+          it { subject.must_equal(_value) }
+        end
 
-      context 'when the value is an Array' do
-        context 'and the value is empty' do
-          let(:_value)   { [] }
-          let(:expected) { Vedeu::Page.coerce(Vedeu::Row.coerce(_value)) }
+        context 'when the value is a Vedeu::Models::Row' do
+          let(:_value)   { Vedeu::Models::Row.new }
+          let(:expected) { described.new([_value]) }
 
-          it { subject.must_be_instance_of(Vedeu::Page) }
           it { subject.must_equal(expected) }
         end
 
-        context 'and the value is not empty, the content is' do
-          context 'is an empty Array' do
-            let(:_value)   { [[]] }
-            let(:expected) { Vedeu::Page.coerce(Vedeu::Row.coerce([])) }
+        context 'when the value is an Array' do
+          context 'and the value is empty' do
+            let(:_value)   { [] }
+            let(:expected) {
+              described.coerce(Vedeu::Models::Row.coerce(_value))
+            }
 
-            it { subject.must_be_instance_of(Vedeu::Page) }
+            it { subject.must_be_instance_of(described) }
             it { subject.must_equal(expected) }
           end
 
-          context 'an array of Vedeu::Row objects' do
-            let(:_value) {
-              [
-                Vedeu::Row.new([:hydrogen, :helium]),
-                Vedeu::Row.new([:lithium, :beryllium]),
-              ]
-            }
-            let(:expected) { Vedeu::Page.new(_value) }
+          context 'and the value is not empty, the content is' do
+            context 'is an empty Array' do
+              let(:_value)   { [[]] }
+              let(:expected) { described.coerce(Vedeu::Models::Row.coerce([])) }
 
-            it { subject.must_equal(expected) }
-          end
+              it { subject.must_be_instance_of(described) }
+              it { subject.must_equal(expected) }
+            end
 
-          context 'a mix of Vedeu::Row objects and other objects' do
-            let(:_value) {
-              [
-                Vedeu::Row.new([:hydrogen, :helium]),
-                [:lithium],
-                Vedeu::Row.new([:beryllium, :boron]),
-              ]
-            }
-            let(:expected) {
-              Vedeu::Page.new([
-                Vedeu::Row.new([:hydrogen, :helium]),
-                Vedeu::Row.new([:lithium]),
-                Vedeu::Row.new([:beryllium, :boron]),
-              ])
-            }
+            context 'an array of Vedeu::Models::Row objects' do
+              let(:_value) {
+                [
+                  Vedeu::Models::Row.new([:hydrogen, :helium]),
+                  Vedeu::Models::Row.new([:lithium, :beryllium]),
+                ]
+              }
+              let(:expected) { described.new(_value) }
 
-            it { subject.must_equal(expected) }
-          end
+              it { subject.must_equal(expected) }
+            end
 
-          context 'a mix of Vedeu::Row objects, other objects and nils' do
-            let(:_value) {
-              [
-                Vedeu::Row.new([:hydrogen, :helium]),
-                nil,
-                [:lithium],
-                Vedeu::Row.new([:beryllium, :boron]),
-                [nil, :carbon],
-              ]
-            }
-            let(:expected) {
-              Vedeu::Page.new([
-                Vedeu::Row.new([:hydrogen, :helium]),
-                Vedeu::Row.new([]),
-                Vedeu::Row.new([:lithium]),
-                Vedeu::Row.new([:beryllium, :boron]),
-                Vedeu::Row.new([:carbon]),
-              ])
-            }
+            context 'a mix of Vedeu::Models::Row objects and other objects' do
+              let(:_value) {
+                [
+                  Vedeu::Models::Row.new([:hydrogen, :helium]),
+                  [:lithium],
+                  Vedeu::Models::Row.new([:beryllium, :boron]),
+                ]
+              }
+              let(:expected) {
+                described.new([
+                  Vedeu::Models::Row.new([:hydrogen, :helium]),
+                  Vedeu::Models::Row.new([:lithium]),
+                  Vedeu::Models::Row.new([:beryllium, :boron]),
+                ])
+              }
+
+              it { subject.must_equal(expected) }
+            end
+
+            context 'a mix of Vedeu::Models::Row objects, other objects and ' \
+                    'nils' do
+              let(:_value) {
+                [
+                  Vedeu::Models::Row.new([:hydrogen, :helium]),
+                  nil,
+                  [:lithium],
+                  Vedeu::Models::Row.new([:beryllium, :boron]),
+                  [nil, :carbon],
+                ]
+              }
+              let(:expected) {
+                described.new([
+                  Vedeu::Models::Row.new([:hydrogen, :helium]),
+                  Vedeu::Models::Row.new([]),
+                  Vedeu::Models::Row.new([:lithium]),
+                  Vedeu::Models::Row.new([:beryllium, :boron]),
+                  Vedeu::Models::Row.new([:carbon]),
+                ])
+              }
+
+              it { subject.must_equal(expected) }
+            end
 
-            it { subject.must_equal(expected) }
           end
 
         end
-
       end
-    end
 
-    describe '#each' do
-      subject { instance.each }
+      describe '#each' do
+        subject { instance.each }
 
-      it { subject.must_be_instance_of(Enumerator) }
-    end
+        it { subject.must_be_instance_of(Enumerator) }
+      end
 
-    describe '#eql?' do
-      let(:other) { instance }
+      describe '#eql?' do
+        let(:other) { instance }
 
-      subject { instance.eql?(other) }
+        subject { instance.eql?(other) }
 
-      it { subject.must_equal(true) }
+        it { subject.must_equal(true) }
 
-      context 'when different to other' do
-        let(:other) { described.new([:hydrogen]) }
+        context 'when different to other' do
+          let(:other) { described.new([:hydrogen]) }
 
-        it { subject.must_equal(false) }
+          it { subject.must_equal(false) }
+        end
       end
-    end
 
-    describe '#row' do
-      let(:index) {}
+      describe '#row' do
+        let(:index) {}
 
-      subject { instance.row(index) }
+        subject { instance.row(index) }
 
-      context 'when the index is nil' do
-        it { subject.must_equal(nil) }
-      end
+        context 'when the index is nil' do
+          it { subject.must_equal(nil) }
+        end
 
-      context 'when the index is not nil' do
-        context 'and the index is in range' do
-          let(:index) { 1 }
+        context 'when the index is not nil' do
+          context 'and the index is in range' do
+            let(:index) { 1 }
 
-          it { subject.must_equal([:beryllium, :boron, :carbon]) }
-        end
+            it { subject.must_equal([:beryllium, :boron, :carbon]) }
+          end
 
-        context 'and the index is out of range' do
-          let(:index) { 4 }
+          context 'and the index is out of range' do
+            let(:index) { 4 }
 
-          it { subject.must_equal(nil) }
-        end
+            it { subject.must_equal(nil) }
+          end
 
-        context 'and the index is out of range' do
-          let(:index) { -4 }
+          context 'and the index is out of range' do
+            let(:index) { -4 }
 
-          it { subject.must_equal(nil) }
+            it { subject.must_equal(nil) }
+          end
         end
       end
-    end
 
-    describe '#cell' do
-      let(:row_index)  {}
-      let(:cell_index) {}
+      describe '#cell' do
+        let(:row_index)  {}
+        let(:cell_index) {}
 
-      subject { instance.cell(row_index, cell_index) }
-
-      context 'when the row_index is nil' do
-        it { subject.must_equal(nil) }
-      end
+        subject { instance.cell(row_index, cell_index) }
 
-      context 'when the row_index is not nil' do
-        let(:row_index) { 1 }
+        context 'when the row_index is nil' do
+          it { subject.must_equal(nil) }
+        end
 
-        context 'and the row_index is in range' do
+        context 'when the row_index is not nil' do
           let(:row_index) { 1 }
 
-          context 'when the cell_index is nil' do
-            it { subject.must_equal(nil) }
-          end
-
-          context 'when the cell_index is not nil' do
-            context 'and the cell_index is in range' do
-              let(:cell_index) { 2 }
+          context 'and the row_index is in range' do
+            let(:row_index) { 1 }
 
-              it { subject.must_equal(:carbon) }
+            context 'when the cell_index is nil' do
+              it { subject.must_equal(nil) }
             end
 
-            context 'and the cell_index is out of range' do
-              let(:cell_index) { 4 }
+            context 'when the cell_index is not nil' do
+              context 'and the cell_index is in range' do
+                let(:cell_index) { 2 }
 
-              it { subject.must_equal(nil) }
-            end
+                it { subject.must_equal(:carbon) }
+              end
 
-            context 'and the cell_index is out of range' do
-              let(:cell_index) { -4 }
+              context 'and the cell_index is out of range' do
+                let(:cell_index) { 4 }
 
-              it { subject.must_equal(nil) }
+                it { subject.must_equal(nil) }
+              end
+
+              context 'and the cell_index is out of range' do
+                let(:cell_index) { -4 }
+
+                it { subject.must_equal(nil) }
+              end
             end
           end
-        end
 
-        context 'and the row_index is out of range' do
-          let(:row_index) { 4 }
+          context 'and the row_index is out of range' do
+            let(:row_index) { 4 }
 
-          it { subject.must_equal(nil) }
-        end
+            it { subject.must_equal(nil) }
+          end
 
-        context 'and the row_index is out of range' do
-          let(:row_index) { -4 }
+          context 'and the row_index is out of range' do
+            let(:row_index) { -4 }
 
-          it { subject.must_equal(nil) }
+            it { subject.must_equal(nil) }
+          end
         end
       end
-    end
 
-  end # Page
+    end # Page
+
+  end # Models
 
 end # Vedeu

data/test/lib/vedeu/models/row_test.rb

@@ -2,110 +2,114 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Row do
+  module Models
 
-    let(:described) { Vedeu::Row }
-    let(:instance)  { described.new(cells) }
-    let(:cells)     { [:hydrogen, :helium, :lithium] }
+    describe Row do
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
+      let(:described) { Vedeu::Models::Row }
+      let(:instance)  { described.new(cells) }
+      let(:cells)     { [:hydrogen, :helium, :lithium] }
 
-      context 'when there are no cells' do
-        let(:cells) {}
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
 
-        it { instance.instance_variable_get('@cells').must_equal([]) }
-      end
+        context 'when there are no cells' do
+          let(:cells) {}
+
+          it { instance.instance_variable_get('@cells').must_equal([]) }
+        end
 
-      context 'when there are cells' do
-        it { instance.instance_variable_get('@cells').must_equal(cells) }
+        context 'when there are cells' do
+          it { instance.instance_variable_get('@cells').must_equal(cells) }
+        end
       end
-    end
 
-    describe '.coerce' do
-      subject { described.coerce(_value) }
+      describe '.coerce' do
+        subject { described.coerce(_value) }
 
-      context 'when the value is a Vedeu::Row' do
-        let(:_value) { Vedeu::Row.new }
+        context 'when the value is a Vedeu::Models::Row' do
+          let(:_value) { described.new }
 
-        it { subject.must_equal(_value) }
-      end
+          it { subject.must_equal(_value) }
+        end
 
-      context 'when the value is an Array' do
-        let(:_value) { [:hydrogen, :helium, :lithium] }
+        context 'when the value is an Array' do
+          let(:_value) { [:hydrogen, :helium, :lithium] }
 
-        it { subject.must_equal(Vedeu::Row.new(_value)) }
-      end
+          it { subject.must_equal(described.new(_value)) }
+        end
 
-      context 'when the value is an Array containing nil objects' do
-        let(:_value) { [:hydrogen, nil, :lithium] }
+        context 'when the value is an Array containing nil objects' do
+          let(:_value) { [:hydrogen, nil, :lithium] }
 
-        it { subject.must_equal(Vedeu::Row.new([:hydrogen, :lithium])) }
-      end
+          it { subject.must_equal(described.new([:hydrogen, :lithium])) }
+        end
 
-      context 'when the value is nil' do
-        let(:_value) {}
+        context 'when the value is nil' do
+          let(:_value) {}
 
-        it { subject.must_equal(Vedeu::Row.new) }
-      end
+          it { subject.must_equal(described.new) }
+        end
 
-      context 'when the value is anything else' do
-        let(:_value) { :beryllium }
+        context 'when the value is anything else' do
+          let(:_value) { :beryllium }
 
-        it { subject.must_equal(Vedeu::Row.new([_value])) }
+          it { subject.must_equal(described.new([_value])) }
+        end
       end
-    end
 
-    describe '#each' do
-      subject { instance.each }
+      describe '#each' do
+        subject { instance.each }
 
-      it { subject.must_be_instance_of(Enumerator) }
-    end
+        it { subject.must_be_instance_of(Enumerator) }
+      end
 
-    describe '#eql?' do
-      let(:other) { instance }
+      describe '#eql?' do
+        let(:other) { instance }
 
-      subject { instance.eql?(other) }
+        subject { instance.eql?(other) }
 
-      it { subject.must_equal(true) }
+        it { subject.must_equal(true) }
 
-      context 'when different to other' do
-        let(:other) { described.new([:hydrogen]) }
+        context 'when different to other' do
+          let(:other) { described.new([:hydrogen]) }
 
-        it { subject.must_equal(false) }
+          it { subject.must_equal(false) }
+        end
       end
-    end
 
-    describe '#cell' do
-      let(:index) {}
+      describe '#cell' do
+        let(:index) {}
 
-      subject { instance.cell(index) }
+        subject { instance.cell(index) }
 
-      context 'when the index is nil' do
-        it { subject.must_equal(nil) }
-      end
+        context 'when the index is nil' do
+          it { subject.must_equal(nil) }
+        end
 
-      context 'when the index is not nil' do
-        context 'and the index is in range' do
-          let(:index) { 1 }
+        context 'when the index is not nil' do
+          context 'and the index is in range' do
+            let(:index) { 1 }
 
-          it { subject.must_equal(:helium) }
-        end
+            it { subject.must_equal(:helium) }
+          end
 
-        context 'and the index is out of range' do
-          let(:index) { 4 }
+          context 'and the index is out of range' do
+            let(:index) { 4 }
 
-          it { subject.must_equal(nil) }
-        end
+            it { subject.must_equal(nil) }
+          end
 
-        context 'and the index is out of range' do
-          let(:index) { -4 }
+          context 'and the index is out of range' do
+            let(:index) { -4 }
 
-          it { subject.must_equal(nil) }
+            it { subject.must_equal(nil) }
+          end
         end
       end
-    end
 
-  end # Row
+    end # Row
+
+  end # Models
 
 end # Vedeu