vedeu 0.6.4 → 0.6.5

data/test/lib/vedeu/borders/borders_test.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Borders do
-
-    let(:described) { Vedeu::Borders }
-
-    it { described.must_respond_to(:borders) }
-
-  end # Borders
-
-end # Vedeu

data/test/lib/vedeu/borders/render_border_test.rb

@@ -1,121 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe RenderBorder do
-
-    let(:described)   { Vedeu::RenderBorder }
-    let(:instance)    { described.new(border) }
-    let(:border)      {
-      Vedeu::Border.new(enabled:     enabled,
-                        name:        _name,
-                        title:       title,
-                        caption:     caption,
-                        show_top:    show_top,
-                        show_bottom: show_bottom,
-                        show_left:   show_left,
-                        show_right:  show_right)
-    }
-    let(:visible)     { false }
-    let(:enabled)     { false }
-    let(:_name)       { 'Vedeu::RenderBorder' }
-    let(:title)       {}
-    let(:caption)     {}
-    let(:show_top)    { true }
-    let(:show_bottom) { true }
-    let(:show_left)   { true }
-    let(:show_right)  { true }
-
-    it { described.must_respond_to(:with) }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@border').must_equal(border) }
-    end
-
-    describe '#render' do
-      let(:geometry) {
-        Vedeu::Geometry.new(name: _name, x: 1, xn: 7, y: 1, yn: 4)
-      }
-      let(:interface) {
-        Vedeu::Interface.new(name: _name, visible: visible)
-      }
-      before do
-        Vedeu.geometries.stubs(:by_name).returns(geometry)
-        Vedeu.interfaces.stubs(:by_name).returns(interface)
-      end
-
-      subject { instance.render }
-
-      context 'when the interface is not visible' do
-        it { subject.must_equal([]) }
-      end
-
-      context 'when the interface is visible' do
-        let(:visible) { true }
-
-        context 'when the border is not enabled' do
-          it { subject.must_equal([]) }
-        end
-
-        context 'when the border is enabled' do
-          let(:enabled) { true }
-
-          context 'and a title is given' do
-            let(:title) { 'T' }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(18) }
-          end
-
-          context 'and a title is not given' do
-            # @todo Add more tests.
-            it { subject.size.must_equal(18) }
-          end
-
-          context 'and a caption is given' do
-            let(:caption) { 'C' }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(18) }
-          end
-
-          context 'and a caption is not given' do
-            # @todo Add more tests.
-            it { subject.size.must_equal(18) }
-          end
-
-          context 'and the left side is disabled' do
-            let(:show_left) { false }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(16) }
-          end
-
-          context 'and the right side is disabled' do
-            let(:show_right) { false }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(16) }
-          end
-
-          context 'and the top side is disabled' do
-            let(:show_top) { false }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(13) }
-          end
-
-          context 'and the bottom side is disabled' do
-            let(:show_bottom) { false }
-
-            # @todo Add more tests.
-            it { subject.size.must_equal(13) }
-          end
-        end
-      end
-    end
-
-  end # RenderBorder
-
-end # Vedeu

data/test/lib/vedeu/buffers/buffers_test.rb

@@ -1,14 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Buffers do
-
-    let(:described) { Vedeu::Buffers }
-    let(:instance)  { described.buffers }
-
-    it { described.must_respond_to(:buffers) }
-
-  end # Buffers
-
-end # Vedeu

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

@@ -1,246 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Cursor do
-
-    let(:described)   { Vedeu::Cursor }
-    let(:instance)    { described.new(attributes) }
-    let(:attributes)  {
-      {
-        name:       _name,
-        ox:         ox,
-        oy:         oy,
-        repository: repository,
-        visible:    visible,
-        x:          x,
-        y:          y,
-      }
-    }
-    let(:_name)      { 'silver' }
-    let(:ox)         { 3 }
-    let(:oy)         { 2 }
-    let(:repository) { Vedeu.cursors }
-    let(:visible)    { true }
-    let(:x)          { 19 }
-    let(:y)          { 8 }
-    let(:border)    { Vedeu::Border.new(name: _name, enabled: enabled) }
-    let(:geometry)  {
-      Vedeu::Geometry.new(
-        name: _name,
-        x:    5,
-        xn:   35,
-        y:    5,
-        yn:   10
-      )
-    }
-    let(:enabled) { true }
-
-    before do
-      Vedeu.borders.stubs(:by_name).returns(border)
-      Vedeu.geometries.stubs(:by_name).returns(geometry)
-    end
-
-    describe '#initialize' do
-      subject { instance }
-
-      it { subject.must_be_instance_of(described) }
-      it { subject.instance_variable_get('@name').must_equal('silver') }
-      it { subject.instance_variable_get('@ox').must_equal(3) }
-      it { subject.instance_variable_get('@oy').must_equal(2) }
-      it { subject.instance_variable_get('@repository').must_equal(repository) }
-      it { subject.instance_variable_get('@visible').must_equal(true) }
-      it { subject.instance_variable_get('@x').must_equal(19) }
-      it { subject.instance_variable_get('@y').must_equal(8) }
-    end
-
-    describe 'accessors' do
-      it { instance.must_respond_to(:attributes) }
-      it { instance.must_respond_to(:name) }
-      it { instance.must_respond_to(:ox) }
-      it { instance.must_respond_to(:ox=) }
-      it { instance.must_respond_to(:oy) }
-      it { instance.must_respond_to(:oy=) }
-      it { instance.must_respond_to(:state) }
-      it { instance.must_respond_to(:x=) }
-      it { instance.must_respond_to(:y=) }
-    end
-
-    describe '#hide' do
-      let(:visible)     { true }
-      let(:hide_cursor) { Vedeu::Escape.new(value: Vedeu::Esc.hide_cursor) }
-
-      before do
-        Vedeu::Output.stubs(:render).
-          with(hide_cursor).returns(hide_cursor)
-      end
-
-      subject { instance.hide }
-
-      it { subject.must_be_instance_of(Vedeu::Escape) }
-    end
-
-    describe '#position' do
-      subject { instance.position }
-
-      it { subject.must_be_instance_of(Vedeu::Position) }
-    end
-
-    describe '#show' do
-      let(:visible) { false }
-      let(:show_cursor) { Vedeu::Escape.new(value: Vedeu::Esc.show_cursor) }
-
-      before do
-        Vedeu::Output.stubs(:render).
-          with(show_cursor).returns(show_cursor)
-      end
-
-      subject { instance.show }
-
-      it { subject.must_be_instance_of(Vedeu::Escape) }
-    end
-
-    describe '#to_s' do
-      let(:visible) { true }
-
-      subject { instance.to_s }
-
-      it { instance.must_respond_to(:to_str) }
-      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(:visible) { 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[8;19H\e[?25h")
-        end
-      end
-    end
-
-    describe '#x' do
-      subject { instance.x }
-
-      context 'when x is less than tx' do
-        let(:x) { -2 }
-
-        it { subject.must_equal(6) }
-      end
-
-      context 'when x is less than left' do
-        let(:x) { 2 }
-
-        it { subject.must_equal(6) }
-      end
-
-      context 'when x is less than bx' do
-        let(:x) { 5 }
-
-        it { subject.must_equal(6) }
-
-        context 'when border is not enabled' do
-          let(:enabled) { false }
-
-          it { subject.must_equal(5) }
-        end
-      end
-
-      context 'when x is more than txn' do
-        let(:x) { 47 }
-
-        it { subject.must_equal(34) }
-      end
-
-      context 'when x is more than right' do
-        let(:x) { 37 }
-
-        it { subject.must_equal(34) }
-      end
-
-      context 'when x is more than bxn' do
-        let(:x) { 35 }
-
-        it { subject.must_equal(34) }
-
-        context 'when border is not enabled' do
-          let(:enabled) { false }
-
-          it { subject.must_equal(35) }
-        end
-      end
-    end
-
-    describe '#y' do
-      subject { instance.y }
-
-      context 'when y is less than ty' do
-        let(:y) { -2 }
-
-        it { subject.must_equal(6) }
-      end
-
-      context 'when y is less than top' do
-        let(:y) { 2 }
-
-        it { subject.must_equal(6) }
-      end
-
-      context 'when y is less than by' do
-        let(:y) { 5 }
-
-        it { subject.must_equal(6) }
-
-        context 'when border is not enabled' do
-          let(:enabled) { false }
-
-          it { subject.must_equal(5) }
-        end
-      end
-
-      context 'when y is more than tyn' do
-        let(:y) { 17 }
-
-        it { subject.must_equal(9) }
-      end
-
-      context 'when y is more than bottom' do
-        let(:y) { 12 }
-
-        it { subject.must_equal(9) }
-      end
-
-      context 'when y is more than byn' do
-        let(:y) { 10 }
-
-        it { subject.must_equal(9) }
-
-        context 'when border is not enabled' do
-          let(:enabled) { false }
-
-          it { subject.must_equal(10) }
-        end
-      end
-    end
-
-  end # Cursor
-
-end # Vedeu

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

@@ -1,37 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Cursors do
-
-    let(:described) { Vedeu::Cursors }
-
-    it { described.must_respond_to(:cursors) }
-
-    describe '.cursor' do
-      subject { Vedeu.cursor }
-
-      context 'when there are cursors are defined' do
-        before do
-          Vedeu::Focus.reset
-          Vedeu.cursors.reset
-          Vedeu::Focus.add('Vedeu.cursor')
-          Vedeu::Cursor.new(name: 'Vedeu.cursor').store
-        end
-
-        it { subject.must_be_instance_of(Vedeu::Cursor) }
-      end
-
-      context 'when there are no cursors defined' do
-        before do
-          Vedeu::Focus.reset
-          Vedeu.cursors.reset
-        end
-
-        it { subject.must_be_instance_of(NilClass) }
-      end
-    end
-
-  end # Cursors
-
-end # Vedeu

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

@@ -1,301 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Move do
-
-    let(:described) { Vedeu::Move }
-    let(:instance)  { described.new(entity, _name, dy, dx) }
-    let(:entity)    { Vedeu::Cursor }
-    let(:_name)     { '' }
-    let(:dy)        { 0 }
-    let(:dx)        { 0 }
-    let(:ox)        { 0 }
-    let(:oy)        { 0 }
-    let(:x)         { 1 }
-    let(:y)         { 1 }
-
-    let(:cursor) {
-      Vedeu::Cursor.new(name: _name, ox: ox, oy: oy, visible: true, x: x, y: y)
-    }
-    let(:new_cursor) {
-      Vedeu::Cursor.new
-    }
-    let(:border) {
-      Vedeu::Border.new(name: '_name', enabled: enabled)
-    }
-    let(:enabled)  { true }
-    let(:geometry) {
-      Vedeu::Geometry.new(name: _name, x: 5, xn: 10, y: 5, yn: 10)
-    }
-
-    before do
-      IO.console.stubs(:winsize).returns([10, 40])
-      IO.console.stubs(:print)
-
-      Vedeu.borders.stubs(:by_name).returns(border)
-      Vedeu.cursors.stubs(:by_name).returns(cursor)
-      Vedeu.geometries.stubs(:by_name).returns(geometry)
-
-      Vedeu.stubs(:trigger).with(:_refresh_cursor_, _name)
-    end
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@entity').must_equal(entity) }
-      it { instance.instance_variable_get('@name').must_equal(_name) }
-      it { instance.instance_variable_get('@dy').must_equal(dy) }
-      it { instance.instance_variable_get('@dx').must_equal(dx) }
-    end
-
-    describe '.by_name' do
-      let(:direction) { :down }
-      let(:_name)     { 'manganese' }
-      let(:oy)        { 2 }
-      let(:ox)        { 3 }
-      let(:x)         { 8 }
-      let(:y)         { 7 }
-
-      before { Vedeu.stubs(:focus).returns('neon') }
-
-      subject { described.by_name(entity, direction, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'when the name is not specified' do
-        let(:_name) {}
-
-        it 'uses the current focussed interface name' do
-          Vedeu::Move.expects(:send).with(:down, Vedeu::Cursor, 'neon')
-          subject
-        end
-      end
-
-      context 'when the name is specified' do
-        let(:_name) { 'manganese' }
-
-        context 'and the direction is down' do
-          let(:direction) { :down }
-
-          it { subject.oy.must_equal(3) }
-        end
-        context 'and the direction is left' do
-          let(:direction) { :left }
-
-          it { subject.ox.must_equal(2) }
-        end
-        context 'and the direction is right' do
-          let(:direction) { :right }
-
-          it { subject.ox.must_equal(4) }
-        end
-        context 'and the direction is up' do
-          let(:direction) { :up }
-
-          it { subject.oy.must_equal(1) }
-        end
-      end
-    end
-
-    describe '.down' do
-      let(:_name) { 'move_down' }
-
-      subject { described.down(entity, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'when within the boundary of the interface' do
-        let(:enabled) { false }
-        let(:_name) { 'move_without_border' }
-        let(:oy)    { 15 }
-
-        it 'does not move past the bottom of the interface' do
-          subject.y.must_equal(10)
-        end
-      end
-
-      context 'when within the border of the interface' do
-        let(:enabled) { true }
-        let(:_name) { 'move_with_border' }
-        let(:oy)    { 15 }
-
-        it 'does not move past the bottom border' do
-          subject.y.must_equal(9)
-        end
-      end
-    end
-
-    describe '.left' do
-      let(:_name) { 'move_left' }
-
-      subject { described.left(entity, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'when within the boundary of the interface' do
-        let(:enabled) { false }
-        let(:_name) { 'move_without_border' }
-
-        it 'does not move past the left of the interface' do
-          subject.x.must_equal(5)
-        end
-      end
-
-      context 'when within the border of the interface' do
-        let(:enabled) { true }
-        let(:_name) { 'move_with_border' }
-
-        it 'does not move past the left border' do
-          subject.x.must_equal(6)
-        end
-      end
-    end
-
-    describe '.right' do
-      let(:_name) { 'move_right' }
-
-      subject { described.right(entity, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'when within the boundary of the interface' do
-        let(:enabled) { false }
-        let(:_name) { 'move_without_border' }
-        let(:ox)    { 15 }
-
-        it 'does not move past the right of the interface' do
-          subject.x.must_equal(10)
-        end
-      end
-
-      context 'when within the border of the interface' do
-        let(:enabled) { true }
-        let(:_name) { 'move_with_border' }
-        let(:ox)    { 15 }
-
-        it 'does not move past the right border' do
-          subject.x.must_equal(9)
-        end
-      end
-    end
-
-    describe '.up' do
-      let(:_name) { 'move_up' }
-
-      subject { described.up(entity, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'when within the boundary of the interface' do
-        let(:enabled) { false }
-        let(:_name) { 'move_without_border' }
-
-        it 'does not move past the top of the interface' do
-          subject.y.must_equal(5)
-        end
-      end
-
-      context 'when within the border of the interface' do
-        let(:enabled) { true }
-        let(:_name) { 'move_with_border' }
-
-        it 'does not move past the top border' do
-          subject.y.must_equal(6)
-        end
-      end
-    end
-
-    describe '.origin' do
-      let(:_name) { 'move_origin' }
-
-      subject { described.origin(entity, _name) }
-
-      it { subject.must_be_instance_of(Vedeu::Cursor) }
-
-      context 'within the boundary of the interface' do
-        let(:enabled) { false }
-        let(:_name) { 'move_without_border' }
-
-        it { subject.x.must_equal(5) }
-        it { subject.y.must_equal(5) }
-      end
-
-      context 'within the border of the interface' do
-        let(:enabled) { true }
-        let(:_name) { 'move_with_border' }
-
-        it { subject.x.must_equal(6) }
-        it { subject.y.must_equal(6) }
-      end
-    end
-
-    describe '#move' do
-      let(:_name) { 'move_move' }
-
-      before { Vedeu.stubs(:trigger) }
-
-      subject { instance.move }
-
-      context 'when the entity is a Vedeu::Geometry' do
-        let(:entity) { Vedeu::Geometry }
-
-        it { subject.must_be_instance_of(Vedeu::Geometry) }
-      end
-
-      context 'when the entity is a Vedeu::Cursor' do
-        it { subject.must_be_instance_of(Vedeu::Cursor) }
-      end
-    end
-
-    describe '#refresh' do
-      before { Vedeu.stubs(:trigger) }
-
-      subject { instance.refresh }
-
-      context 'when the entity is a Vedeu::Geometry' do
-        let(:entity) { Vedeu::Geometry }
-
-        it {
-          Vedeu.expects(:trigger)
-          subject
-        }
-      end
-
-      context 'when the entity is a Vedeu::Cursor' do
-        it {
-          Vedeu.expects(:trigger)
-          subject
-        }
-      end
-    end
-
-    describe '#merged_attributes' do
-      subject { instance.merged_attributes }
-
-      it { subject.must_be_instance_of(Hash) }
-
-      context 'when the entity is a Vedeu::Geometry' do
-        let(:entity)   { Vedeu::Geometry }
-        let(:expected) {
-          {
-            centred: false,
-            maximised: false,
-            name: '',
-            x: 5,
-            y: 5,
-            xn: 10,
-            yn: 10
-          }
-        }
-
-        it { subject.must_equal(expected) }
-      end
-
-      context 'when the entity is a Vedeu::Cursor' do
-        it { subject.must_be_instance_of(Hash) }
-      end
-    end
-
-  end # Move
-
-end # Vedeu