vedeu 0.5.13 → 0.6.0

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

@@ -0,0 +1,184 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe VirtualCursor do
+
+      let(:described) { Vedeu::Editor::VirtualCursor }
+      let(:instance)  {
+        described.new(y:   y,
+                      x:   x,
+                      bx:  bx,
+                      by:  by,
+                      byn: byn,
+                      bxn: bxn,
+                      oy:  oy,
+                      ox:  ox)
+      }
+      let(:y)         { 0 }
+      let(:x)         { 0 }
+      let(:by)        { 1 }
+      let(:bx)        { 1 }
+      let(:byn)       { 6 }
+      let(:bxn)       { 6 }
+      let(:oy)        { 0 }
+      let(:ox)        { 0 }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@y').must_equal(y) }
+        it { instance.instance_variable_get('@x').must_equal(x) }
+        it { instance.instance_variable_get('@by').must_equal(by) }
+        it { instance.instance_variable_get('@bx').must_equal(bx) }
+        it { instance.instance_variable_get('@byn').must_equal(byn) }
+        it { instance.instance_variable_get('@bxn').must_equal(bxn) }
+        it { instance.instance_variable_get('@oy').must_equal(0) }
+        it { instance.instance_variable_get('@ox').must_equal(0) }
+
+        context 'when x is nil' do
+          it { instance.instance_variable_get('@x').must_equal(0) }
+        end
+
+        context 'when x is not nil' do
+          let(:x) { 3 }
+
+          it { instance.instance_variable_get('@x').must_equal(3) }
+        end
+
+        context 'when y is nil' do
+          it { instance.instance_variable_get('@y').must_equal(0) }
+        end
+
+        context 'when y is not nil' do
+          let(:y) { 6 }
+
+          it { instance.instance_variable_get('@y').must_equal(6) }
+        end
+      end
+
+      describe '#accessors' do
+        it { instance.must_respond_to(:bx) }
+        it { instance.must_respond_to(:bx=) }
+        it { instance.must_respond_to(:by) }
+        it { instance.must_respond_to(:by=) }
+        it { instance.must_respond_to(:bxn) }
+        it { instance.must_respond_to(:bxn=) }
+        it { instance.must_respond_to(:byn) }
+        it { instance.must_respond_to(:byn=) }
+        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(:x) }
+        it { instance.must_respond_to(:x=) }
+        it { instance.must_respond_to(:y) }
+        it { instance.must_respond_to(:y=) }
+      end
+
+      describe '#bol' do
+        let(:x)  { 11 }
+        let(:ox) { 4 }
+
+        subject { instance.bol }
+
+        it { subject.must_be_instance_of(described) }
+
+        it { subject.x.must_equal(0) }
+        it { subject.ox.must_equal(0) }
+      end
+
+      describe '#down' do
+        let(:y) { 11 }
+
+        subject { instance.down }
+
+        it { subject.must_be_instance_of(described) }
+
+        it { subject.y.must_equal(12) }
+      end
+
+      describe '#left' do
+        let(:x)  { 11 }
+        let(:ox) { 4 }
+
+        subject { instance.left }
+
+        it { subject.must_be_instance_of(described) }
+
+        it { subject.x.must_equal(10) }
+        it { subject.ox.must_equal(3) }
+      end
+
+      describe '#reset!' do
+        let(:x)  { 11 }
+        let(:y)  { 5 }
+        let(:ox) { 4 }
+        let(:oy) { 2 }
+
+        subject { instance.reset! }
+
+        it { subject.must_be_instance_of(described) }
+        it { subject.x.must_equal(0) }
+        it { subject.y.must_equal(0) }
+        it { subject.ox.must_equal(0) }
+        it { subject.oy.must_equal(0) }
+      end
+
+      describe '#right' do
+        let(:x) { 11 }
+
+        subject { instance.right }
+
+        it { subject.must_be_instance_of(described) }
+
+        it { subject.x.must_equal(12) }
+      end
+
+      describe '#to_s' do
+        let(:x) { 11 }
+        let(:y) { 5 }
+
+        subject { instance.to_s }
+
+        it { subject.must_be_instance_of(String) }
+
+        it { subject.must_equal("\e[6;6H\e[?25h") }
+      end
+
+      describe '#up' do
+        let(:y)  { 11 }
+        let(:oy) { 2 }
+
+        subject { instance.up }
+
+        it { subject.must_be_instance_of(described) }
+
+        it { subject.y.must_equal(10) }
+        it { subject.oy.must_equal(1) }
+      end
+
+      describe '#x' do
+        subject { instance.x }
+
+        it { subject.must_be_instance_of(Fixnum) }
+
+        # @todo Add more tests.
+        # it { skip }
+      end
+
+      describe '#y' do
+        subject { instance.x }
+
+        it { subject.must_be_instance_of(Fixnum) }
+
+        # @todo Add more tests.
+        # it { skip }
+      end
+
+    end # VirtualCursor
+
+  end # Editor
+
+end # Vedeu

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

@@ -18,14 +18,16 @@ module Vedeu
     describe '.capture' do
       before do
         reader.stubs(:raw_mode?).returns(raw_mode)
+        reader.stubs(:fake_mode?).returns(fake_mode)
         Vedeu.stubs(:trigger).returns([false])
       end
 
       subject { described.capture(reader) }
 
       context 'when in cooked mode' do
-        let(:raw_mode) { false }
-        let(:command)  { 'help' }
+        let(:raw_mode)  { false }
+        let(:fake_mode) { false }
+        let(:command)   { 'help' }
 
         before { reader.stubs(:read).returns(command) }
 
@@ -35,9 +37,23 @@ module Vedeu
         end
       end
 
+      context 'when in fake mode' do
+        let(:raw_mode)  { false }
+        let(:fake_mode) { true }
+        let(:keypress)  { 'b' }
+
+        before { reader.stubs(:read).returns(keypress) }
+
+        it 'triggers an event with the keypress' do
+          Vedeu.expects(:trigger).with(:_editor_, keypress)
+          subject
+        end
+      end
+
       context 'when in raw mode' do
-        let(:raw_mode) { true }
-        let(:keypress) { 'a' }
+        let(:raw_mode)  { true }
+        let(:fake_mode) { false }
+        let(:keypress)  { 'a' }
 
         before { reader.stubs(:read).returns(keypress) }
 

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

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe InputTranslator do
+
+    let(:described) { Vedeu::InputTranslator }
+    let(:instance)  { described.new(code) }
+    let(:code)      {}
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+      it { instance.instance_variable_get('@code').must_equal(code) }
+    end
+
+    describe '.translate' do
+      context 'when the code is not recognised' do
+        it { described.translate('a').must_equal('a') }
+      end
+
+      context 'when the code is recognised' do
+        it { described.translate("\e[H").must_equal(:home) }
+      end
+    end
+
+    describe '#translate' do
+      it { instance.must_respond_to(:translate) }
+    end
+
+  end # InputTranslator
+
+end # Vedeu

data/test/lib/vedeu/internal_api_test.rb

@@ -9,6 +9,7 @@ module Vedeu
       it { Vedeu.must_respond_to(:buffers) }
       it { Vedeu.must_respond_to(:cursors) }
       it { Vedeu.must_respond_to(:debug) }
+      it { Vedeu.must_respond_to(:documents) }
       it { Vedeu.must_respond_to(:events) }
       it { Vedeu.must_respond_to(:foreground_colours) }
       it { Vedeu.must_respond_to(:geometries) }

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

@@ -24,8 +24,12 @@ module Vedeu
       it { instance.must_respond_to(:value) }
     end
 
-    describe '#colour' do
-      it { instance.colour.must_equal('') }
+    describe '#null' do
+      it { instance.null.must_equal(nil) }
+      it { instance.background.must_equal(nil) }
+      it { instance.colour.must_equal(nil) }
+      it { instance.foreground.must_equal(nil) }
+      it { instance.style.must_equal(nil) }
     end
 
     describe '#eql?' do
@@ -48,10 +52,6 @@ module Vedeu
       it { instance.position.must_be_instance_of(Vedeu::Position) }
     end
 
-    describe '#style' do
-      it { instance.style.must_equal('') }
-    end
-
     describe '#value' do
       it { instance.value.must_be_instance_of(String) }
     end

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

@@ -83,8 +83,21 @@ module Vedeu
       end
 
       describe '#visible?' do
-        # @todo Add more tests.
-        # it { skip }
+        subject { instance.visible? }
+
+        context 'when the interface is visible' do
+          let(:interface) { Vedeu::Interface.new(visible: true) }
+
+          before do
+            Vedeu.interfaces.stubs(:by_name).with(_name).returns(interface)
+          end
+
+          it { subject.must_equal(true) }
+        end
+
+        context 'when the interface is not visible' do
+          it { subject.must_equal(false) }
+        end
       end
 
     end # View

data/test/lib/vedeu/null/null_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Null do
+  end # Null
+
+end # Vedeu

data/test/lib/vedeu/output/direct_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Direct do
+
+    let(:described) { Vedeu::Direct }
+    let(:instance)  { described.new(value: _value, x: x, y: y) }
+    let(:_value)    {}
+    let(:x)         {}
+    let(:y)         {}
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+
+      context 'when no value is given' do
+        it { instance.instance_variable_get('@value').must_equal('') }
+      end
+
+      context 'when a value is given' do
+        let(:_value) { 'some value' }
+
+        it { instance.instance_variable_get('@value').must_equal('some value') }
+      end
+
+      context 'when no x is given' do
+        it { instance.instance_variable_get('@x').must_equal(1) }
+      end
+
+      context 'when an x is given' do
+        let(:x) { 6 }
+        it { instance.instance_variable_get('@x').must_equal(6) }
+      end
+
+      context 'when no y is given' do
+        it { instance.instance_variable_get('@y').must_equal(1) }
+      end
+
+      context 'when a y is given' do
+        let(:y) { 3 }
+
+        it { instance.instance_variable_get('@y').must_equal(3) }
+      end
+    end
+
+    describe '.write' do
+      before { Vedeu::Terminal.stubs(:output) }
+
+      subject { described.write(value: _value, x: x, y: y) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when a value is given' do
+        let(:_value) { 'some value' }
+
+        it { subject.must_equal("\e[1;1Hsome value") }
+      end
+
+      context 'when a value is not given' do
+        it { subject.must_equal("\e[1;1H") }
+      end
+    end
+
+    describe '#write' do
+      it { instance.must_respond_to(:write) }
+    end
+
+  end # Direct
+
+end # Vedeu

data/test/lib/vedeu/terminal/content_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Terminal
+
+    describe Content do
+
+      let(:described) { Vedeu::Terminal::Content }
+
+      describe '.valid?' do
+        let(:char) { mock }
+
+        subject { described.valid?(char) }
+
+        context 'when the char does not respond to :position' do
+          it { subject.must_equal(false) }
+        end
+
+        context 'when the char responds to :position' do
+          let(:position) { mock }
+
+          before do
+            char.stubs(:position).returns(position)
+            position.stubs(:x).returns(x)
+            position.stubs(:y).returns(y)
+          end
+
+          context 'but the y value is not present' do
+            let(:x) { 2 }
+            let(:y) {}
+
+            it { subject.must_equal(false) }
+          end
+
+          context 'but the x value is not present' do
+            let(:x) {}
+            let(:y) { 5 }
+
+            it { subject.must_equal(false) }
+          end
+
+          context 'and both y and x values are present' do
+            let(:x) { 2 }
+            let(:y) { 5 }
+
+            it { subject.must_equal(true) }
+          end
+        end
+      end
+
+      describe '#store' do
+        let(:char) {}
+
+        subject { described.store(char) }
+      end
+
+      describe '#stores' do
+        let(:chars) {}
+
+        subject { described.stores(chars) }
+      end
+
+      describe '#write' do
+        subject { described.write }
+
+        context 'when logging is enabled' do
+          # before { Vedeu::Configuration.stubs(:log?).returns(true) }
+          # before { File.stubs(:write) }
+
+          # it {
+          #   File.expects(:write)
+          #   subject
+          # }
+        end
+
+        context 'when logging is not enabled' do
+          before { Vedeu::Configuration.stubs(:log?).returns(false) }
+
+          it { subject.must_equal(nil) }
+        end
+      end
+
+      describe '#reprocess' do
+        subject { described.reprocess }
+      end
+
+      describe '#reset' do
+        subject { described.reset }
+
+        it { subject.must_be_instance_of(Hash) }
+
+        it { subject.must_be_empty }
+      end
+
+    end # Content
+
+  end # Terminal
+
+end # Vedeu