vedeu 0.8.8 → 0.8.9

data/test/lib/vedeu/coercers/style_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module Vedeu
+
+  module Coercers
+
+    describe Style do
+
+      let(:described) { Vedeu::Coercers::Style }
+      let(:instance)  { described.new(_value) }
+      let(:_value)    {}
+      let(:klass)     { Vedeu::Presentation::Style }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@value').must_equal(_value) }
+      end
+
+      describe '.coerce' do
+        it { described.must_respond_to(:coerce) }
+      end
+
+      describe '#coerce' do
+        subject { instance.coerce }
+
+        context 'when the value is already the target class' do
+          let(:_value) { klass.new }
+
+          it { subject.must_be_instance_of(klass) }
+          it { subject.must_equal(_value) }
+        end
+
+        context 'when the value is nil' do
+          let(:_value) { nil }
+
+          it { subject.must_be_instance_of(klass) }
+        end
+
+        context 'when the value is an Array' do
+          let(:_value)  { [:bold, :blink] }
+
+          it { subject.value.must_equal([:bold, :blink]) }
+        end
+
+        context 'when the value is a Hash' do
+          let(:_value) {
+            {
+              style: [:bold, :blink]
+            }
+          }
+
+          it { subject.value.must_equal([:bold, :blink]) }
+        end
+      end
+
+    end # Style
+
+  end # Coercers
+
+end # Vedeu

data/test/lib/vedeu/cursors/coordinate_test.rb

@@ -12,25 +12,24 @@ module Vedeu
       let(:instance)   { described.new(attributes) }
       let(:attributes) {
         {
-          name:   _name,
-          offset: offset,
-          type:   type,
+          geometry: geometry,
+          offset:   offset,
+          type:     type,
         }
       }
-      let(:_name)      {}
-      let(:offset)     {}
-      let(:type)       {}
       let(:geometry)   {
-        Vedeu::Geometries::Geometry.new(name: _name, x: 2, y: 3, xn: 10, yn: 6)
+        Vedeu::Geometries::Geometry.new(name: :vedeu_cursors_coordinate,
+                                        x:    2,
+                                        y:    3,
+                                        xn:   10,
+                                        yn:   6)
       }
-
-      before do
-        Vedeu.geometries.stubs(:by_name).returns(geometry)
-      end
+      let(:offset)     {}
+      let(:type)       {}
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
-        it { instance.instance_variable_get('@name').must_equal(_name) }
+        it { instance.instance_variable_get('@geometry').must_equal(geometry) }
         it { instance.instance_variable_get('@offset').must_equal(offset) }
         it { instance.instance_variable_get('@type').must_equal(type) }
       end

data/test/lib/vedeu/geometries/position_test.rb

@@ -60,82 +60,38 @@ module Vedeu
       describe '.[]' do
         subject { described.[](y, x) }
 
-        it { instance.must_be_instance_of(described) }
+        it { subject.must_be_instance_of(described) }
 
         context 'when the x and y coordinates are given' do
-          it { instance.y.must_equal(12) }
-          it { instance.x.must_equal(19) }
+          it { subject.y.must_equal(12) }
+          it { subject.x.must_equal(19) }
         end
 
         context 'when the x coordinate is not given' do
           let(:x) {}
 
-          it { instance.y.must_equal(12) }
-          it { instance.x.must_equal(1) }
+          it { subject.y.must_equal(12) }
+          it { subject.x.must_equal(1) }
         end
 
         context 'when the y coordinate is not given' do
           let(:y) {}
 
-          it { instance.y.must_equal(1) }
-          it { instance.x.must_equal(19) }
+          it { subject.y.must_equal(1) }
+          it { subject.x.must_equal(19) }
         end
 
         context 'when the x and y coordinates are not given' do
           let(:x) {}
           let(:y) {}
 
-          it { instance.y.must_equal(1) }
-          it { instance.x.must_equal(1) }
+          it { subject.y.must_equal(1) }
+          it { subject.x.must_equal(1) }
         end
       end
 
       describe '.coerce' do
-        let(:_value) {}
-
-        subject { described.coerce(_value) }
-
-        context 'when the value is already a Position' do
-          let(:_value) { instance }
-
-          it { subject.must_equal(instance) }
-        end
-
-        context 'when the value is an Array' do
-          let(:_value) { [2, 8] }
-
-          it { subject.must_be_instance_of(described) }
-          it { subject.y.must_equal(2) }
-          it { subject.x.must_equal(8) }
-        end
-
-        context 'when the value is an Fixnum' do
-          let(:_value) { 2 }
-
-          it { subject.must_be_instance_of(described) }
-          it { subject.y.must_equal(2) }
-          it { subject.x.must_equal(1) }
-        end
-
-        context 'when the value is a Hash' do
-          let(:_value) { { y: 3, x: 9 } }
-
-          it { subject.must_be_instance_of(described) }
-          it { subject.y.must_equal(3) }
-          it { subject.x.must_equal(9) }
-        end
-
-        context 'when the value is a NilClass' do
-          let(:_value) {}
-
-          it { subject.must_be_instance_of(NilClass) }
-        end
-
-        context 'when the value is something unhandled' do
-          let(:_value) { :invalid }
-
-          it { subject.must_be_instance_of(NilClass) }
-        end
+        it { described.must_respond_to(:coerce) }
       end
 
       describe '#<=>' do

data/test/lib/vedeu/input/capture_test.rb

@@ -40,7 +40,7 @@ module Vedeu
 
         subject { described.read }
 
-        it 'appends "Waiting for user input..." to the log' do
+        it 'writes to the log file' do
           Vedeu.expects(:log)
           subject
         end

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

@@ -32,124 +32,12 @@ module Vedeu
         end
       end
 
-      describe '#rows' do
-        it { instance.must_respond_to(:rows) }
-      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::Models::Page' do
-          let(:_value) { described.new }
-
-          it { subject.must_equal(_value) }
-        end
-
-        context 'when the value is a Vedeu::Models::Row' do
-          let(:_value)   { Vedeu::Models::Row.new }
-          let(:expected) { described.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) {
-              described.coerce(Vedeu::Models::Row.coerce(_value))
-            }
-
-            it { subject.must_be_instance_of(described) }
-            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) { described.coerce(Vedeu::Models::Row.coerce([])) }
-
-              it { subject.must_be_instance_of(described) }
-              it { subject.must_equal(expected) }
-            end
-
-            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
-
-            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]),
-                  [
-                    Vedeu::Cells::Char.new(value: 'b'),
-                    Vedeu::Cells::Char.new(value: 'o'),
-                    Vedeu::Cells::Char.new(value: 'r'),
-                    Vedeu::Cells::Char.new(value: 'o'),
-                    Vedeu::Cells::Char.new(value: 'n'),
-                  ],
-                  [nil, :carbon],
-                  :nitrogen,
-                ]
-              }
-              let(:expected) {
-                described.new([
-                  Vedeu::Models::Row.new([:hydrogen, :helium]),
-                  Vedeu::Models::Row.new([]),
-                  Vedeu::Models::Row.new([:lithium]),
-                  Vedeu::Models::Row.new([:beryllium]),
-                  Vedeu::Models::Row.new([
-                    Vedeu::Cells::Char.new(value: 'b'),
-                    Vedeu::Cells::Char.new(value: 'o'),
-                    Vedeu::Cells::Char.new(value: 'r'),
-                    Vedeu::Cells::Char.new(value: 'o'),
-                    Vedeu::Cells::Char.new(value: 'n'),
-                  ]),
-                  Vedeu::Models::Row.new([:carbon]),
-                  Vedeu::Models::Row.new([:nitrogen]),
-                ])
-              }
-
-              it { subject.must_equal(expected) }
-            end
-
-          end
+        it { described.must_respond_to(:coerce) }
+      end
 
-        end
+      describe '#rows' do
+        it { instance.must_respond_to(:rows) }
       end
 
       describe '#cell' do

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

@@ -33,37 +33,7 @@ module Vedeu
       end
 
       describe '.coerce' do
-        subject { described.coerce(_value) }
-
-        context 'when the value is a Vedeu::Models::Row' do
-          let(:_value) { described.new }
-
-          it { subject.must_equal(_value) }
-        end
-
-        context 'when the value is an Array' do
-          let(:_value) { [:hydrogen, :helium, :lithium] }
-
-          it { subject.must_equal(described.new(_value)) }
-        end
-
-        context 'when the value is an Array containing nil objects' do
-          let(:_value) { [:hydrogen, nil, :lithium] }
-
-          it { subject.must_equal(described.new([:hydrogen, :lithium])) }
-        end
-
-        context 'when the value is nil' do
-          let(:_value) {}
-
-          it { subject.must_equal(described.new) }
-        end
-
-        context 'when the value is anything else' do
-          let(:_value) { :beryllium }
-
-          it { subject.must_equal(described.new([_value])) }
-        end
+        it { described.must_respond_to(:coerce) }
       end
 
       describe '#cell' do

data/test/lib/vedeu/presentation/style_test.rb

@@ -17,6 +17,10 @@ module Vedeu
         it { instance.instance_variable_get('@value').must_equal('bold') }
       end
 
+      describe '.coerce' do
+        it { described.must_respond_to(:coerce) }
+      end
+
       describe '#escape_sequences' do
         it { instance.must_respond_to(:escape_sequences) }
       end
@@ -29,44 +33,6 @@ module Vedeu
         it { instance.must_respond_to(:value=) }
       end
 
-      describe '.coerce' do
-        let(:_value) { 'bold' }
-
-        subject { described.coerce(_value) }
-
-        it { subject.must_be_instance_of(described) }
-
-        context 'when the value is nil' do
-          let(:_value) { nil }
-
-          it { subject.must_be_instance_of(described) }
-        end
-
-        context 'when the value is a Style already' do
-          let(:_value) { Vedeu::Presentation::Style.new('bold') }
-
-          it 'returns the value' do
-            subject.must_equal(_value)
-          end
-        end
-
-        context 'when the value is an Array' do
-          let(:_value)  { [:bold, :blink] }
-
-          it { subject.value.must_equal([:bold, :blink]) }
-        end
-
-        context 'when the value is a Hash' do
-          let(:_value) {
-            {
-              style: [:bold, :blink]
-            }
-          }
-
-          it { subject.value.must_equal([:bold, :blink]) }
-        end
-      end
-
       describe '#attributes' do
         subject { instance.attributes }
 

data/test/lib/vedeu/renderers/all_test.rb

@@ -27,6 +27,12 @@ module Vedeu
     }
     after  { Vedeu::Renderers.reset }
 
+    describe '.clear' do
+      subject { described.clear }
+
+      it { described.must_respond_to(:clear) }
+    end
+
     describe '.renderers' do
       subject { described.renderers }
 

data/test/lib/vedeu/support/point_test.rb

@@ -26,7 +26,19 @@ module Vedeu
         it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
       end
 
-      context 'when :max is not a Fixnum' do
+      context 'when :min is not given' do
+        subject { described.coerce(value: _value, max: max) }
+
+        it { subject.must_be_instance_of(Vedeu::Point) }
+      end
+
+      context 'when :max is not given' do
+        subject { described.coerce(value: _value, min: min) }
+
+        it { subject.must_be_instance_of(Vedeu::Point) }
+      end
+
+      context 'when :max is not a Fixnum or Float::INFINITY' do
         let(:max) { :invalid }
 
         it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }