vedeu 0.2.12 → 0.3.0

data/test/lib/vedeu/cursor/cursor_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+require 'vedeu/cursor/cursor'
+
+module Vedeu
+
+  describe Cursor do
+
+    let(:described)   { Vedeu::Cursor }
+    let(:instance)    { described.new(attributes) }
+    let(:attributes)  {
+      {
+        name:       _name,
+        ox:         ox,
+        oy:         oy,
+        repository: repository,
+        state:      state,
+        x:          x,
+        y:          y,
+      }
+    }
+    let(:_name)      { 'silver' }
+    let(:ox)         { 3 }
+    let(:oy)         { 2 }
+    let(:repository) { Vedeu.cursors }
+    let(:state)      { :show }
+    let(:x)          { 19 }
+    let(:y)          { 8 }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(Cursor) }
+
+      # it { instance.instance_variable_get('@attributes').must_equal() }
+      it { instance.instance_variable_get('@name').must_equal('silver') }
+      it { instance.instance_variable_get('@ox').must_equal(3) }
+      it { instance.instance_variable_get('@oy').must_equal(2) }
+      it { instance.instance_variable_get('@repository').must_equal(Vedeu.cursors) }
+      it { instance.instance_variable_get('@state').must_be_instance_of(Vedeu::Visible) }
+      it { instance.instance_variable_get('@x').must_equal(19) }
+      it { instance.instance_variable_get('@y').must_equal(8) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Cursor (silver: x:19 y:8 ox:3 oy:2)>') }
+    end
+
+    describe '#to_s' do
+      let(:state) { true }
+
+      subject { instance.to_s }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when the cursor is visible' do
+        it 'returns an visible cursor escape sequence with position' do
+          subject.must_equal("\e[8;19H\e[?25h")
+        end
+      end
+
+      context 'when the cursor is invisible' do
+        let(:state) { false }
+
+        it 'returns the invisible cursor escape sequence with position' do
+          subject.must_equal("\e[8;19H\e[?25l")
+        end
+      end
+
+      context 'when a block is given' do
+        subject {
+          instance.to_s do
+            # ...
+          end
+        }
+
+        it 'returns the escape sequence to position and set the visibility of ' \
+           'the cursor and returns to that position after yielding the block' do
+          subject.must_equal("\e[8;19H\e[?25h\e[8;19H\e[?25h")
+        end
+      end
+    end
+
+  end # Cursor
+
+end # Vedeu

data/test/lib/vedeu/cursor/move_cursor_test.rb

@@ -0,0 +1,212 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe MoveCursor do
+
+    let(:described) { Vedeu::MoveCursor }
+    let(:instance)  { described.new(cursor, interface, dy, dx) }
+    let(:cursor)    { Cursor.new({ name: 'MoveCursor', ox: ox, oy: oy, state: :show, x: x, y: y }) }
+    let(:ox)        { 0 }
+    let(:oy)        { 0 }
+    let(:x)         { 1 }
+    let(:y)         { 1 }
+
+    let(:interface) {
+      Vedeu::Interface.build do
+        name 'magnesium'
+        geometry do
+
+        end
+      end
+    }
+    let(:interface_with_border) {
+      Vedeu::Interface.build do
+        name 'manganese'
+        border do
+          # ...
+        end
+        geometry do
+          height 5
+          width 5
+          x 5
+          y 5
+        end
+      end
+    }
+    let(:interface_without_border) {
+      Vedeu::Interface.build do
+        name 'meitnerium'
+        geometry do
+          height 5
+          width 5
+          x 5
+          y 5
+        end
+      end
+    }
+
+    let(:dy)        { 0 }
+    let(:dx)        { 0 }
+
+    before { IO.console.stubs(:winsize).returns([25, 80]) }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Vedeu::MoveCursor) }
+      it { subject.instance_variable_get('@cursor').must_equal(cursor) }
+      it { subject.instance_variable_get('@interface').must_equal(interface) }
+      it { subject.instance_variable_get('@dy').must_equal(dy) }
+      it { subject.instance_variable_get('@dx').must_equal(dx) }
+    end
+
+    describe '.down' do
+      subject { MoveCursor.down(cursor, interface) }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+
+      it { subject.y.must_equal(2) }
+
+      context 'when moving, the cursor must be within the boundary of the ' \
+              'interface' do
+        subject { MoveCursor.down(cursor, interface_without_border) }
+        let(:y) { 15 }
+
+        it 'does not move past the bottom of the interface' do
+          subject.y.must_equal(6)
+        end
+      end
+
+      context 'when moving, the cursor must be within the border of the ' \
+              'interface' do
+        subject { MoveCursor.down(cursor, interface_with_border) }
+        let(:y)         { 15 }
+
+        it 'does not move past the bottom border' do
+          subject.y.must_equal(6)
+        end
+      end
+    end
+
+    describe '.left' do
+      subject { MoveCursor.left(cursor, interface) }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+
+      it { subject.x.must_equal(1) }
+
+      context 'when moving, the cursor must be within the boundary of the ' \
+              'interface' do
+        subject { MoveCursor.left(cursor, interface_without_border) }
+        let(:x)         { 3 }
+
+        it 'does not move past the left of the interface' do
+          subject.x.must_equal(3)
+        end
+      end
+
+      context 'when moving, the cursor must be within the border of the ' \
+              'interface' do
+        subject { MoveCursor.left(cursor, interface_with_border) }
+        let(:x)         { 4 }
+
+        it 'does not move past the left border' do
+          subject.x.must_equal(4)
+        end
+      end
+    end
+
+    describe '.right' do
+      subject { MoveCursor.right(cursor, interface) }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+
+      it { subject.x.must_equal(2) }
+
+      context 'when moving, the cursor must be within the boundary of the ' \
+              'interface' do
+        subject { MoveCursor.right(cursor, interface_without_border) }
+        let(:x)         { 14 }
+
+        it 'does not move past the right of the interface' do
+          subject.x.must_equal(6)
+        end
+      end
+
+      context 'when moving, the cursor must be within the border of the ' \
+              'interface' do
+        subject { MoveCursor.right(cursor, interface_with_border) }
+
+        let(:x)         { 14 }
+
+        it 'does not move past the right border' do
+          subject.x.must_equal(6)
+        end
+      end
+    end
+
+    describe '.up' do
+      subject { MoveCursor.up(cursor, interface) }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+
+      it { subject.y.must_equal(1) }
+
+      context 'when moving, the cursor must be within the boundary of the ' \
+              'interface' do
+        subject { MoveCursor.up(cursor, interface_without_border) }
+
+        let(:y)         { 3 }
+
+        it 'does not move past the top of the interface' do
+          subject.y.must_equal(3)
+        end
+      end
+
+      context 'when moving, the cursor must be within the border of the ' \
+              'interface' do
+        subject { MoveCursor.up(cursor, interface_with_border) }
+
+        let(:y)         { 3 }
+
+        it 'does not move past the top border' do
+          subject.y.must_equal(3)
+        end
+      end
+    end
+
+    describe '#origin' do
+      subject { MoveCursor.origin(cursor, interface) }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+
+      context 'within the visible area for the console' do
+        it { subject.x.must_equal(1) }
+        it { subject.y.must_equal(1) }
+      end
+
+      context 'within the boundary of the interface' do
+        subject { MoveCursor.origin(cursor, interface_without_border) }
+
+        it { subject.x.must_equal(5) }
+        it { subject.y.must_equal(5) }
+      end
+
+      context 'within the border of the interface' do
+        subject { MoveCursor.origin(cursor, interface_with_border) }
+
+        it { subject.x.must_equal(6) }
+        it { subject.y.must_equal(6) }
+      end
+    end
+
+    describe '#move' do
+      subject { MoveCursor.new(cursor, interface, dy, dx).move }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+    end
+
+  end # MoveCursor
+
+end # Vedeu

data/test/lib/vedeu/cursor/toggle_cursor_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe ToggleCursor do
+
+    let(:described) { ToggleCursor.new(cursor) }
+    let(:cursor)    { Cursor.new({ name: 'vanadium',
+                                   ox: 1,
+                                   oy: 1,
+                                   state: state,
+                                   x: 1,
+                                   y: 1 }) }
+    let(:state)     { true }
+
+    describe '#initialize' do
+      it { described.must_be_instance_of(ToggleCursor) }
+      it { described.instance_variable_get('@cursor').must_equal(cursor) }
+    end
+
+    describe '.hide' do
+      subject { ToggleCursor.hide(cursor) }
+
+      it { subject.must_be_instance_of(Cursor) }
+
+      context 'when the cursor is visible' do
+        it 'returns a new cursor' do
+          subject.wont_equal(cursor)
+        end
+      end
+
+      context 'when the cursor is invisible' do
+        let(:state) { false }
+
+        it 'returns the cursor' do
+          subject.must_equal(cursor)
+        end
+      end
+    end
+
+    describe '.show' do
+      subject { ToggleCursor.show(cursor) }
+
+      it { subject.must_be_instance_of(Cursor) }
+
+      context 'when the cursor is visible' do
+        it 'returns the cursor' do
+          subject.must_equal(cursor)
+        end
+      end
+
+      context 'when the cursor is invisible' do
+        let(:state) { false }
+
+        it 'returns a new cursor' do
+          subject.wont_equal(cursor)
+        end
+      end
+    end
+
+  end # ToggleCursor
+
+end # Vedeu