vedeu 0.6.4 → 0.6.5

data/test/lib/vedeu/geometry/repository_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Geometry
+
+    describe Repository do
+
+      let(:described) { Vedeu::Geometry::Repository }
+
+      after { Vedeu.geometries.reset }
+
+      it { described.must_respond_to(:geometries) }
+
+    end # Repository
+
+  end # Geometry
+
+end # Vedeu

data/test/lib/vedeu/input/editor/document_test.rb

@@ -52,7 +52,7 @@ module Vedeu
         }
 
         before do
-          Vedeu::Geometry.new(name: _name, x: 1, y: 1, xn: 5, yn: 5).store
+          Vedeu::Geometry::Geometry.new(name: _name, x: 1, y: 1, xn: 5, yn: 5).store
           Vedeu::Terminal.stubs(:output)
           Vedeu::Direct.stubs(:write).returns(expected)
         end

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

@@ -49,7 +49,7 @@ module Vedeu
     end
 
     describe '#position' do
-      it { instance.position.must_be_instance_of(Vedeu::Position) }
+      it { instance.position.must_be_instance_of(Vedeu::Geometry::Position) }
     end
 
     describe '#value' do

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

@@ -64,7 +64,7 @@ module Vedeu
     end
 
     describe '#hide' do
-      let(:buffer) { Vedeu::Buffer.new }
+      let(:buffer) { Vedeu::Buffers::Buffer.new }
 
       before { Vedeu.buffers.stubs(:by_name).returns(buffer) }
 
@@ -77,7 +77,7 @@ module Vedeu
     end
 
     describe '#show' do
-      let(:buffer) { Vedeu::Buffer.new }
+      let(:buffer) { Vedeu::Buffers::Buffer.new }
 
       before { Vedeu.buffers.stubs(:by_name).returns(buffer) }
 

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

@@ -0,0 +1,235 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Page do
+
+    let(:described) { Vedeu::Page }
+    let(:instance)  { described.new(rows) }
+    let(:rows)      {
+      [
+        [:hydrogen, :helium, :lithium],
+        [:beryllium, :boron, :carbon],
+        [:nitrogen, :oxygen, :fluorine],
+      ]
+    }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+
+      context 'when there are no rows' do
+        let(:rows) {}
+
+        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
+
+    describe '.coerce' do
+      let(:_value) {}
+
+      subject { described.coerce(_value) }
+
+      it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
+
+      context 'when the value is a Vedeu::Page' do
+        let(:_value) { Vedeu::Page.new }
+
+        it { subject.must_equal(_value) }
+      end
+
+      context 'when the value is a Vedeu::Row' do
+        let(:_value)   { Vedeu::Row.new }
+        let(:expected) { Vedeu::Page.new([_value]) }
+
+        it { subject.must_equal(expected) }
+      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)) }
+
+          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([])) }
+
+            it { subject.must_be_instance_of(Vedeu::Page) }
+            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) }
+
+            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]),
+              ])
+            }
+
+            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]),
+              ])
+            }
+
+            it { subject.must_equal(expected) }
+          end
+
+        end
+
+      end
+    end
+
+    describe '#each' do
+      subject { instance.each }
+
+      it { subject.must_be_instance_of(Enumerator) }
+    end
+
+    describe '#eql?' do
+      let(:other) { instance }
+
+      subject { instance.eql?(other) }
+
+      it { subject.must_equal(true) }
+
+      context 'when different to other' do
+        let(:other) { described.new([:hydrogen]) }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#row' do
+      let(:index) {}
+
+      subject { instance.row(index) }
+
+      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 }
+
+          it { subject.must_equal([:beryllium, :boron, :carbon]) }
+        end
+
+        context 'and the index is out of range' do
+          let(:index) { 4 }
+
+          it { subject.must_equal(nil) }
+        end
+
+        context 'and the index is out of range' do
+          let(:index) { -4 }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+    end
+
+    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
+
+      context 'when the row_index is not nil' do
+        let(:row_index) { 1 }
+
+        context 'and the row_index is in range' 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 }
+
+              it { subject.must_equal(:carbon) }
+            end
+
+            context 'and the cell_index is out of range' do
+              let(:cell_index) { 4 }
+
+              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
+
+        context 'and the row_index is out of range' do
+          let(:row_index) { 4 }
+
+          it { subject.must_equal(nil) }
+        end
+
+        context 'and the row_index is out of range' do
+          let(:row_index) { -4 }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+    end
+
+  end # Page
+
+end # Vedeu

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

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Row do
+
+    let(:described) { Vedeu::Row }
+    let(:instance)  { described.new(cells) }
+    let(:cells)     { [:hydrogen, :helium, :lithium] }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+
+      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) }
+      end
+    end
+
+    describe '.coerce' do
+      subject { described.coerce(_value) }
+
+      context 'when the value is a Vedeu::Row' do
+        let(:_value) { Vedeu::Row.new }
+
+        it { subject.must_equal(_value) }
+      end
+
+      context 'when the value is an Array' do
+        let(:_value) { [:hydrogen, :helium, :lithium] }
+
+        it { subject.must_equal(Vedeu::Row.new(_value)) }
+      end
+
+      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
+
+      context 'when the value is nil' do
+        let(:_value) {}
+
+        it { subject.must_equal(Vedeu::Row.new) }
+      end
+
+      context 'when the value is anything else' do
+        let(:_value) { :beryllium }
+
+        it { subject.must_equal(Vedeu::Row.new([_value])) }
+      end
+    end
+
+    describe '#each' do
+      subject { instance.each }
+
+      it { subject.must_be_instance_of(Enumerator) }
+    end
+
+    describe '#eql?' do
+      let(:other) { instance }
+
+      subject { instance.eql?(other) }
+
+      it { subject.must_equal(true) }
+
+      context 'when different to other' do
+        let(:other) { described.new([:hydrogen]) }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#cell' do
+      let(:index) {}
+
+      subject { instance.cell(index) }
+
+      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 }
+
+          it { subject.must_equal(:helium) }
+        end
+
+        context 'and the index is out of range' do
+          let(:index) { 4 }
+
+          it { subject.must_equal(nil) }
+        end
+
+        context 'and the index is out of range' do
+          let(:index) { -4 }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+    end
+
+  end # Row
+
+end # Vedeu

data/test/lib/vedeu/models/views/char_test.rb

@@ -118,7 +118,7 @@ module Vedeu
         it { subject.must_be_instance_of(String) }
 
         context 'when a position is specified' do
-          let(:position) { Vedeu::Position[17, 2] }
+          let(:position) { Vedeu::Geometry::Position[17, 2] }
 
           it { subject.must_equal("\e[17;2Ha") }
         end
@@ -204,7 +204,7 @@ module Vedeu
       end
 
       describe '#x' do
-        let(:position) { Vedeu::Position[17, 2] }
+        let(:position) { Vedeu::Geometry::Position[17, 2] }
 
         subject { instance.x }
 
@@ -220,7 +220,7 @@ module Vedeu
       end
 
       describe '#y' do
-        let(:position) { Vedeu::Position[17, 2] }
+        let(:position) { Vedeu::Geometry::Position[17, 2] }
 
         subject { instance.y }
 

data/test/lib/vedeu/options_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Options do
+
+    let(:described) { Vedeu::Options }
+    let(:instance)  { described.new(options, defaults) }
+    let(:options)   {}
+    let(:defaults)  {}
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { instance.must_be_instance_of(described) }
+
+      context 'when the options are nil and defaults are nil' do
+        it { instance.instance_variable_get('@options').must_equal({}) }
+        it { instance.instance_variable_get('@defaults').must_equal({}) }
+      end
+
+      context 'when the options are empty and the defaults are empty' do
+        let(:options)  { {} }
+        let(:defaults) { {} }
+
+        it { instance.instance_variable_get('@options').must_equal({}) }
+        it { instance.instance_variable_get('@defaults').must_equal({}) }
+      end
+
+      context 'when an option is set but no default is set' do
+        let(:options)  { { element: :hydrogen } }
+        let(:defaults) { {} }
+
+        it { (instance.methods - Object.methods).must_equal([:element]) }
+        it { instance.element.must_equal(:hydrogen) }
+      end
+
+      context 'when an option is set but a default is set' do
+        let(:options)  { { element: :lithium } }
+        let(:defaults) { { element: :helium } }
+
+        it { (instance.methods - Object.methods).must_equal([:element]) }
+        it { instance.element.must_equal(:lithium) }
+      end
+
+      context 'when no option is set but a default is set' do
+        let(:options)  { {} }
+        let(:defaults) { { element: :beryllium } }
+
+        it { (instance.methods - Object.methods).must_equal([:element]) }
+        it { instance.element.must_equal(:beryllium) }
+      end
+    end
+
+  end # Options
+
+end # Vedeu