vedeu 0.2.12 → 0.3.0

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

@@ -0,0 +1,190 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Coordinate do
+
+    let(:described) { Vedeu::Coordinate }
+    let(:instance)  { described.new(height, width, x, y) }
+    let(:height)    { 6 }
+    let(:width)     { 6 }
+    let(:x)         { 7 }
+    let(:y)         { 5 }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@height').must_equal(height) }
+      it { subject.instance_variable_get('@width').must_equal(width) }
+      it { subject.instance_variable_get('@x').must_equal(x) }
+      it { subject.instance_variable_get('@y').must_equal(y) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal(
+        '<Vedeu::Coordinate ( height:6 width:6 x:7 xn:13 y:5 yn:11 )>'
+      ) }
+    end
+
+    describe '#yn' do
+      subject { instance.yn }
+
+      context 'when the height is <= to 0' do
+        let(:height) { 0 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the height is > 0' do
+        it { subject.must_equal(11) }
+      end
+    end
+
+    describe '#xn' do
+      subject { instance.xn }
+
+      context 'when the width is <= to 0' do
+        let(:width) { 0 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the width is > 0' do
+        it { subject.must_equal(13) }
+      end
+    end
+
+    describe '#y_index' do
+      subject { instance.y_index(position) }
+
+      context 'when the position is <= 0' do
+        let(:position) { -2 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the position is <= y' do
+        let(:position) { 4 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the position is >= yn' do
+        let(:position) { 20 }
+
+        it { subject.must_equal(5) }
+      end
+
+      context 'when the position is > y and < yn' do
+        let(:position) { 8 }
+
+        it { subject.must_equal(3) }
+      end
+    end
+
+    describe '#x_index' do
+      subject { instance.x_index(position) }
+
+      context 'when the position is <= 0' do
+        let(:position) { -2 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the position is <= x' do
+        let(:position) { 4 }
+
+        it { subject.must_equal(0) }
+      end
+
+      context 'when the position is >= xn' do
+        let(:position) { 20 }
+
+        it { subject.must_equal(5) }
+      end
+
+      context 'when the position is > x and < xn' do
+        let(:position) { 8 }
+
+        it { subject.must_equal(1) }
+      end
+    end
+
+    describe '#y_position' do
+      let(:index)  { 0 }
+      let(:height) { 6 }
+      let(:width)  { 6 }
+      let(:x)      { 7 }
+      let(:y)      { 5 }
+
+      subject { instance.y_position(index) }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      context 'with a negative index' do
+        let(:index) { -3 }
+
+        it { subject.must_equal(5) }
+      end
+
+      context 'with an index greater than the maximum index for y' do
+        let(:index) { 9 }
+
+        it { subject.must_equal(11) }
+
+        context 'but the height is negative' do
+          let(:height) { -2 }
+
+          it { subject.must_equal(0) }
+        end
+      end
+
+      context 'with an index within range' do
+        let(:index) { 3 }
+
+        it { subject.must_equal(8) }
+      end
+    end
+
+    describe '#x_position' do
+      let(:index)  { 0 }
+      let(:height) { 6 }
+      let(:width)  { 6 }
+      let(:x)      { 7 }
+      let(:y)      { 5 }
+
+      subject { instance.x_position(index) }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      context 'with a negative index' do
+        let(:index) { -3 }
+
+        it { subject.must_equal(7) }
+      end
+
+      context 'with an index greater than the maximum index for x' do
+        let(:index) { 9 }
+
+        it { subject.must_equal(13) }
+
+        context 'but the width is negative' do
+          let(:width) { -2 }
+
+          it { subject.must_equal(0) }
+        end
+      end
+
+      context 'with an index within range' do
+        let(:index) { 3 }
+
+        it { subject.must_equal(10) }
+      end
+    end
+
+  end # Coordinate
+
+end # Vedeu

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

@@ -28,6 +28,24 @@ module Vedeu
       end
     end
 
+    describe '.escape' do
+      let(:stream) { "\e[0m\e[38;2;39m\e[48;2;49m\e[2J\e[?25l" }
+
+      subject { Esc.escape(stream) }
+
+      it { subject.must_be_instance_of(String) }
+
+      it 'escapes the escape sequences' do
+        subject.must_equal('\e[0m\e[38;2;39m\e[48;2;49m\e[2J\e[?25l')
+      end
+
+      context 'when a stream is not given' do
+        let(:stream) { '' }
+
+        it { Esc.escape(stream).must_equal('') }
+      end
+    end
+
     describe '.string' do
       it 'returns an empty string when the style is not provided' do
         Esc.string.must_equal('')

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

@@ -16,25 +16,30 @@ module Vedeu
 
   describe Grid do
 
-    let(:described) { Grid.new(value) }
+    let(:described) { Vedeu::Grid }
+    let(:instance)  { described.new(value) }
     let(:value)     { 2 }
 
+    before { IO.console.stubs(:winsize).returns([25, 80]) }
+
     describe '#initialize' do
-      it { return_type_for(described, Grid) }
-      it { assigns(described, '@value', value) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Grid) }
+      it { subject.instance_variable_get('@value').must_equal(value) }
     end
 
     describe '.columns' do
-      it 'raises an exception if the value is less than 1' do
-        proc { Grid.columns(0) }.must_raise(OutOfRange)
+      context 'when the value is less than 1' do
+        it { proc { Grid.columns(0) }.must_raise(OutOfRange) }
       end
 
-      it 'raises an exception if the value is greater than 12' do
-        proc { Grid.columns(13) }.must_raise(OutOfRange)
+      context 'when the value is greater than 12' do
+        it { proc { Grid.columns(13) }.must_raise(OutOfRange) }
       end
 
-      it 'returns the width if the value is in range' do
-        IO.console.stub :winsize, [25, 80] do
+      context 'when the value is in range' do
+        it 'returns the value of the column' do
           Grid.columns(7).must_equal(42)
         end
       end
@@ -42,4 +47,4 @@ module Vedeu
 
   end # Grid
 
-  end # Vedeu
+end # Vedeu

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

@@ -3,6 +3,9 @@ require 'test_helper'
 module Vedeu
 
   describe Log do
+
+    # it { skip }
+
   end # Log
 
 end # Vedeu

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

@@ -4,13 +4,21 @@ module Vedeu
 
   describe Position do
 
-    let(:described) { Position.new(12, 19) }
+    let(:described) { Vedeu::Position }
+    let(:instance)  { described.new(12, 19) }
+
 
     describe '#initialize' do
-      it { return_type_for(described, Position) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Position) }
+      it { subject.instance_variable_get('@y').must_equal(12) }
+      it { subject.instance_variable_get('@x').must_equal(19) }
     end
 
     describe '#to_s' do
+      # subject { described.new.to_s }
+
       it 'returns an escape sequence when no coordinates are provided' do
         Position.new.to_s.must_equal("\e[1;1H")
       end
@@ -19,6 +27,18 @@ module Vedeu
         Position.new(12, 19).to_s.must_equal("\e[12;19H")
       end
 
+      it 'returns an escape sequence if a coordinate is missing' do
+        Position.new(12).to_s.must_equal("\e[12;1H")
+      end
+
+      it 'returns an escape sequence if the x coordinate is negative' do
+        Position.new(12, -5).to_s.must_equal("\e[12;1H")
+      end
+
+      it 'returns an escape sequence if the y coordinate is negative' do
+        Position.new(-12, 5).to_s.must_equal("\e[1;5H")
+      end
+
       it 'resets to starting position when a block is given' do
         Position.new(4, 9).to_s { 'test' }.must_equal("\e[4;9Htest\e[4;9H")
       end

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

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe PositionValidator do
+
+
+
+  end # PositionValidator
+
+end # Vedeu

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

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Read do
+
+    let(:described) { Vedeu::Read }
+    let(:instance)  { described.new(console, data) }
+    let(:console)   { Vedeu::Console.new(height, width) }
+    let(:data)      {}
+    let(:height)    { 4 }
+    let(:width)     { 30 }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@console').must_equal(console) }
+      it { subject.instance_variable_get('@data').must_equal(data) }
+    end
+
+    describe '.from' do
+      subject { described.from(console, data) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when no data is given' do
+        it { subject.must_equal('') }
+      end
+
+      context 'when data is given' do
+        let(:data) { 'a' }
+
+        it { subject.must_equal('a') }
+      end
+    end
+
+    describe '#getch' do
+      let(:string) {}
+
+      subject { instance.getch(string) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when no string is given' do
+        it { subject.must_equal('') }
+      end
+
+      context 'when a multi-character string is given' do
+        let(:string) { 'Some text...' }
+
+        it { subject.must_equal('S') }
+      end
+
+      context 'when a single character string is given' do
+        let(:string) { 'a' }
+
+        it { subject.must_equal('a') }
+      end
+    end
+
+    describe '#gets' do
+      let(:string) {}
+
+      subject { instance.gets(string) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when no string is given' do
+        it { subject.must_equal('') }
+      end
+
+      context 'when a string with line feed is given' do
+        let(:string) { "Some text...\n" }
+
+        it { subject.must_equal('Some text...') }
+      end
+
+      context 'when a string without line feed is given' do
+        let(:string) { 'Some text...' }
+
+        it { subject.must_equal('Some text...') }
+      end
+    end
+
+  end # Read
+
+end # Vedeu

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

@@ -4,34 +4,66 @@ module Vedeu
 
   describe Refresh do
 
-    before { Interfaces.reset }
+    let(:described) { Vedeu::Refresh }
+
+    before { Vedeu.interfaces.reset }
 
     describe '.all' do
-      it 'returns an empty collection when there are no registered ' \
-         'interfaces' do
-        Refresh.all.must_equal([])
+      subject { described.all }
+
+      it { subject.must_be_instance_of(Array) }
+
+      context 'when there are no registered interfaces' do
+        it { subject.must_equal([]) }
       end
+
+      # context 'when there are registered interfaces' do
+      #   it { subject, ['hydrogen'.must_equal('helium']) }
+      # end
     end
 
     describe '.by_focus' do
-      it 'raises an exception when there are no registered interfaces' do
-        Focus.reset
+      subject { described.by_focus }
+
+      context 'when there are no registered interfaces' do
+        before { Vedeu.focusable.reset }
+
+        it { Refresh.by_focus.must_equal(nil) }
+      end
+
+      context 'when there are registered interfaces' do
+        # before { Vedeu.focusable.add('lead') }
 
-        proc { Refresh.by_focus }.must_raise(NoInterfacesDefined)
+        # it { subject.must_equal('lead') }
       end
     end
 
     describe '.by_group' do
-      it 'raises an exception when the group cannot be found' do
-        Groups.reset
+      context 'when there are no registered groups' do
+        before { Vedeu.groups.reset }
 
-        proc { Refresh.by_group('') }.must_raise(ModelNotFound)
+        it { proc { Refresh.by_group('') }.must_raise(ModelNotFound) }
+      end
+
+      context 'when there are registered groups' do
       end
     end
 
     describe '.by_name' do
-      it 'raises an exception when the buffer cannot be found' do
-        proc { Refresh.by_name('') }.must_raise(ModelNotFound)
+      let(:interface_name) { 'aluminium' }
+
+      subject { Refresh.by_name(interface_name) }
+
+      context 'when the interface or buffer is not found' do
+        let(:interface_name) { '' }
+
+        it { proc { Refresh.by_name('') }.must_raise(ModelNotFound) }
+      end
+
+      context 'when the interface or buffer is found' do
+        # it { subject.must_be_instance_of(Array) }
+
+        # it { skip }
       end
     end
 

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

@@ -4,14 +4,16 @@ module Vedeu
 
   describe Sentence do
 
-    let(:described) { Sentence.new(elements, label) }
+    let(:described) { Vedeu::Sentence }
+    let(:instance)  { described.new(elements, label) }
     let(:elements)  { ['Hydrogen'] }
     let(:label)     { 'elements' }
 
     describe '#initialize' do
-      it { return_type_for(described, Sentence) }
-      it { assigns(described, '@elements', elements) }
-      it { assigns(described, '@label', label) }
+      subject { instance }
+      it { subject.must_be_instance_of(Sentence) }
+      it { subject.instance_variable_get('@elements').must_equal(elements) }
+      it { subject.instance_variable_get('@label').must_equal(label) }
     end
 
     describe '.construct' do