vedeu 0.2.12 → 0.3.0

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

@@ -4,13 +4,18 @@ module Vedeu
 
   describe Terminal do
 
+    let(:described) { Vedeu::Terminal }
+
     let(:console) { IO.console }
 
-    describe '.open' do
-      before { IO.console.stubs(:print) }
+    before do
+      IO.console.stubs(:winsize).returns([25, 80])
+      IO.console.stubs(:print)
+    end
 
-      it 'raises an exception when no block is given' do
-        proc { Terminal.open }.must_raise(InvalidSyntax)
+    describe '.open' do
+      context 'when a block was not given' do
+        it { proc { Terminal.open }.must_raise(InvalidSyntax) }
       end
 
       it 'opens a new terminal console in raw mode' do
@@ -34,24 +39,66 @@ module Vedeu
       end
     end
 
+    describe '.input' do
+      context 'when the terminal is in cooked mode' do
+        let(:mode)  { :cooked }
+        let(:input) { "Some input\r\n" }
+
+        before do
+          Terminal.stubs(:mode).returns(mode)
+          IO.console.stubs(:gets).returns(input)
+        end
+
+        subject { Terminal.input }
+
+        it { subject.must_equal('Some input') }
+      end
+
+      context 'when the terminal is in raw mode' do
+        let(:mode)  { :raw }
+        let(:input) { "\e" }
+
+        before do
+          Terminal.stubs(:mode).returns(mode)
+          IO.console.stubs(:getch).returns(input)
+          input.stubs(:ord).returns(27)
+          IO.console.stubs(:read_nonblock)
+        end
+
+        subject { Terminal.input }
+
+        it { subject.must_be_instance_of(String) }
+      end
+    end
+
     describe '.output' do
-      before { IO.console.stubs(:print) }
+      subject { described.output(*value) }
+
+      context 'when the value is a String' do
+        let(:value) { 'Some output...' }
 
-      it 'returns the output' do
-        Terminal.output('Some output...').must_equal(['Some output...'])
+        it { subject.must_equal(['Some output...']) }
       end
+      context 'when there are multiple values' do
+        let(:value) { ['Some output...', 'more output...', 'even more...'] }
 
-      it 'returns the output collection' do
-        Terminal.output('Some output...', 'more output...', 'even more...')
-          .must_equal(['Some output...', 'more output...', 'even more...'])
+        it { subject.must_equal(['Some output...', 'more output...', 'even more...']) }
       end
     end
 
-    describe '.clear_screen' do
+    describe '.resize' do
+      before { Vedeu.interfaces.reset }
+
+      subject { Terminal.resize }
+
+      it { subject.must_be_instance_of(TrueClass) }
+    end
+
+    describe '.clear' do
+      subject { Terminal.clear }
+
       it 'clears the screen' do
-        console.stub :print, nil do
-          Terminal.clear_screen.must_equal(["\e[38;2;39m\e[48;2;49m\e[2J"])
-        end
+        subject.must_equal(["\e[38;2;39m\e[48;2;49m\e[2J"])
       end
     end
 
@@ -98,13 +145,11 @@ module Vedeu
 
       it 'returns :cooked if previously :raw' do
         Terminal.raw_mode!
-
         Terminal.switch_mode!.must_equal(:cooked)
       end
 
       it 'returns :raw if previously :cooked' do
         Terminal.cooked_mode!
-
         Terminal.switch_mode!.must_equal(:raw)
       end
     end
@@ -117,61 +162,44 @@ module Vedeu
 
       it 'returns the configured terminal mode' do
         Terminal.mode.must_be_instance_of(Symbol)
-
         Terminal.mode.must_equal(:raw)
       end
     end
 
     describe '.centre' do
       it 'returns the centre point on the terminal' do
-        console.stub :winsize, [25, 80] do
-          Terminal.centre.must_be_instance_of(Array)
-
-          Terminal.centre.must_equal([12, 40])
-        end
+        Terminal.centre.must_be_instance_of(Array)
+        Terminal.centre.must_equal([12, 40])
       end
     end
 
     describe '.centre_y' do
       it 'returns the centre `y` point on the terminal' do
-        console.stub :winsize, [25, 80] do
-          Terminal.centre_y.must_be_instance_of(Fixnum)
-
-          Terminal.centre_y.must_equal(12)
-        end
+        Terminal.centre_y.must_be_instance_of(Fixnum)
+        Terminal.centre_y.must_equal(12)
       end
     end
 
     describe '.centre_x' do
       it 'returns the centre `x` point on the terminal' do
-        console.stub :winsize, [25, 80] do
-          Terminal.centre_x.must_be_instance_of(Fixnum)
-
-          Terminal.centre_x.must_equal(40)
-        end
+        Terminal.centre_x.must_be_instance_of(Fixnum)
+        Terminal.centre_x.must_equal(40)
       end
     end
 
     describe '.origin' do
       it 'returns 1' do
-        console.stub :winsize, [25, 80] do
-          Terminal.origin.must_be_instance_of(Fixnum)
-
-          Terminal.origin.must_equal(1)
-        end
+        Terminal.origin.must_be_instance_of(Fixnum)
+        Terminal.origin.must_equal(1)
       end
 
       context 'alias_methods' do
         it 'returns 1' do
-          console.stub :winsize, [25, 80] do
-            Terminal.x.must_equal(1)
-          end
+          Terminal.x.must_equal(1)
         end
 
         it 'returns 1' do
-          console.stub :winsize, [25, 80] do
-            Terminal.y.must_equal(1)
-          end
+          Terminal.y.must_equal(1)
         end
       end
     end
@@ -179,27 +207,20 @@ module Vedeu
     describe '.width' do
       context 'via method' do
         it 'returns the width of the terminal' do
-          console.stub :winsize, [25, 80] do
-            Terminal.width.must_be_instance_of(Fixnum)
-
-            Terminal.width.must_equal(80)
-          end
+          Terminal.width.must_be_instance_of(Fixnum)
+          Terminal.width.must_equal(80)
         end
       end
 
       context 'via API' do
         it 'returns the width of the terminal' do
-          console.stub :winsize, [24, 40] do
-            Vedeu.width.must_equal(40)
-          end
+          Vedeu.width.must_equal(80)
         end
       end
 
       context 'alias_methods' do
         it 'returns the xn coordinate of the terminal' do
-          console.stub :winsize, [25, 80] do
-            Terminal.xn.must_equal(80)
-          end
+          Terminal.xn.must_equal(80)
         end
       end
     end
@@ -207,38 +228,28 @@ module Vedeu
     describe '.height' do
       context 'via method' do
         it 'returns the height of the terminal' do
-          console.stub :winsize, [25, 80] do
-            Terminal.height.must_be_instance_of(Fixnum)
-
-            Terminal.height.must_equal(25)
-          end
+          Terminal.height.must_be_instance_of(Fixnum)
+          Terminal.height.must_equal(25)
         end
       end
 
       context 'via API' do
         it 'returns the height of the terminal' do
-          console.stub :winsize, [24, 40] do
-            Vedeu.height.must_equal(24)
-          end
+          Vedeu.height.must_equal(25)
         end
       end
 
       context 'alias_methods' do
         it 'returns the yn coordinate of the terminal' do
-          console.stub :winsize, [25, 80] do
-            Terminal.yn.must_equal(25)
-          end
+          Terminal.yn.must_equal(25)
         end
       end
     end
 
     describe '.size' do
       it 'returns the width and height of the terminal' do
-        console.stub :winsize, [25, 80] do
-          Terminal.size.must_be_instance_of(Array)
-
-          Terminal.size.must_equal([25, 80])
-        end
+        Terminal.size.must_be_instance_of(Array)
+        Terminal.size.must_equal([25, 80])
       end
     end
 

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

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Text do
+
+    let(:value)   { 'Testing the Text class with various options' }
+    let(:options) {
+      {
+        anchor: anchor,
+        pad:    pad,
+        width:  width,
+      }
+    }
+    let(:anchor) { :left }
+    let(:pad)    { ' ' }
+    let(:width)  { nil }
+
+    describe '.with' do
+      context 'when a width is provided' do
+        context 'when value longer than the width' do
+          let(:width) { 23 }
+
+          it 'returns the value truncated' do
+            Text.with(value, options).must_equal('Testing the Text class ')
+          end
+        end
+
+        context 'when value is shorter or equal to the width' do
+          let(:width) { 48 }
+
+          context 'and an anchor is not set' do
+            it 'returns the value left aligned' do
+              Text.with(value, options)
+                .must_equal('Testing the Text class with various options     ')
+            end
+          end
+
+          context 'and the anchor is set to :left' do
+            it 'returns the value left aligned' do
+              Text.with(value, options)
+                .must_equal('Testing the Text class with various options     ')
+            end
+          end
+
+          context 'and the anchor is set to :align' do
+            let(:anchor) { :align }
+
+            it 'returns the value left aligned' do
+              Text.with(value, options)
+                .must_equal('Testing the Text class with various options     ')
+            end
+          end
+
+          context 'and the anchor is set to centre' do
+            let(:anchor) { :centre }
+
+            it 'returns the value centre aligned' do
+              Text.with(value, options)
+                .must_equal('  Testing the Text class with various options   ')
+            end
+          end
+
+          context 'and the anchor is set to right' do
+            let(:anchor) { :right }
+
+            it 'returns the value right aligned' do
+              Text.with(value, options)
+                .must_equal('     Testing the Text class with various options')
+            end
+          end
+
+          context 'and the anchor is invalid' do
+            let(:anchor) { :invalid }
+
+            it 'returns the value left aligned' do
+              Text.with(value, options)
+                .must_equal('Testing the Text class with various options     ')
+            end
+          end
+        end
+      end
+
+      context 'when a width is not provided' do
+        it 'returns the value as a string' do
+          Text.with(:some_value).must_equal('some_value')
+        end
+      end
+    end
+
+  end # Text
+
+end # Vedeu

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

@@ -4,20 +4,32 @@ module Vedeu
 
   describe Trace do
 
-    let(:described) { Trace.new(options) }
+    let(:described) { Vedeu::Trace }
+    let(:instance)  { described.new(options) }
     let(:options)   { {} }
 
-    describe '.call' do
-      it { skip }
-    end
-
     describe '#initialize' do
-      it { return_type_for(described, Trace) }
-      it { assigns(described, '@options', options) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Trace) }
+      it { subject.instance_variable_get('@options').must_equal(options) }
     end
 
-    describe '#trace' do
-      it { skip }
+    describe '.call' do
+      subject { described.call(options) }
+
+      context 'when trace is enabled in the configuration' do
+      end
+
+      context 'when trace is disabled in the configuration' do
+        context 'and not enabled via the options' do
+
+        end
+        context 'but enabled via the options' do
+          let(:options) { { trace: true } }
+
+        end
+      end
     end
 
   end # Trace

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

@@ -0,0 +1,148 @@
+require 'test_helper'
+
+require 'vedeu/support/visible'
+
+module Vedeu
+
+  describe Visible do
+
+    let(:described) { Vedeu::Visible }
+    let(:instance)  { described.new(visible) }
+    let(:visible)   { true }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Visible) }
+
+      context 'when visible is :hide' do
+        let(:visible) { :hide }
+
+        it { subject.instance_variable_get('@visible').must_equal(false) }
+      end
+
+      context 'when visible is :show' do
+        let(:visible) { :show }
+
+        it { subject.instance_variable_get('@visible').must_equal(true) }
+      end
+
+      context 'when visible is nil' do
+        let(:visible) { nil }
+
+        it { subject.instance_variable_get('@visible').must_equal(false) }
+      end
+
+      context 'when visible is false' do
+        let(:visible) { false }
+
+        it { subject.instance_variable_get('@visible').must_equal(false) }
+      end
+
+      context 'when visible is anything else that evaluates to true' do
+        let(:visible) { 'yeah show it!' }
+
+        it { subject.instance_variable_get('@visible').must_equal(true) }
+      end
+    end
+
+    describe '.coerce' do
+      subject { described.coerce(value) }
+
+      context 'when the value is a Visible' do
+        let(:value) { described.new }
+
+        it { subject.must_be_instance_of(Visible) }
+        it { subject.visible?.must_equal(false) }
+      end
+
+      context 'when the value is not a Visible' do
+        let(:value) { :show }
+
+        it { subject.must_be_instance_of(Visible) }
+        it { subject.visible?.must_equal(true) }
+      end
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Visible (true)>') }
+    end
+
+    describe '#cursor' do
+      subject { instance.cursor }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when visible' do
+        it { subject.must_equal("\e[?25h") }
+      end
+
+      context 'when not visible' do
+        let(:visible) { false }
+
+        it { subject.must_equal("\e[?25l") }
+      end
+    end
+
+    describe '#visible?' do
+      subject { instance.visible? }
+
+      context 'when visible' do
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+
+      context 'when not visible' do
+        let(:visible) { false }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#invisible?' do
+      subject { instance.invisible? }
+
+      context 'when not visible' do
+        let(:visible) { false }
+
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+
+      context 'when visible' do
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#hide' do
+      subject { instance.hide }
+
+      it { subject.must_be_instance_of(Visible) }
+      it { subject.visible?.must_equal(false) }
+    end
+
+    describe '#show' do
+      subject { instance.show }
+      it { subject.must_be_instance_of(Visible) }
+      it { subject.visible?.must_equal(true) }
+    end
+
+    describe '#toggle' do
+      subject { instance.toggle }
+
+      it { subject.must_be_instance_of(Visible) }
+
+      context 'when visible' do
+        it { subject.visible?.must_be_instance_of(FalseClass) }
+      end
+
+      context 'when not visible' do
+        let(:visible) { false }
+
+        it { subject.visible?.must_be_instance_of(TrueClass) }
+      end
+    end
+
+  end # Visible
+
+end # Vedeu

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

@@ -0,0 +1,136 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Write do
+
+    let(:described) { Vedeu::Write }
+    let(:instance)  { described.new(console, data) }
+    let(:console)   { Vedeu::Console.new(height, width) }
+    let(:data)      {}
+    let(:height)    { 3 }
+    let(:width)     { 40 }
+
+    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 '.to' do
+      subject { described.to(console, data) }
+
+      it { subject.must_be_instance_of(Array) }
+
+      context 'when the data is larger than the visible area' do
+        context 'when the data is a String' do
+          let(:data) {
+            "Zinc, in commerce also spelter, is a chemical\n" \
+            "element with symbol Zn and atomic number 30.\n"  \
+            "It is the first element of group 12 of the\n"    \
+            "periodic table."
+          }
+
+          it { subject.must_equal(
+            [
+              "Zinc, in commerce also spelter, is a che",
+              "element with symbol Zn and atomic number",
+              "It is the first element of group 12 of t"
+            ])
+          }
+        end
+
+        context 'when the data is an Array' do
+          # Zinc...
+          # -.Zn.12
+          # Spelter
+          # ..Metal
+          let(:data) {
+            [
+              [
+                Vedeu::Char.new('Z'),Vedeu::Char.new('i'),Vedeu::Char.new('n'),
+                Vedeu::Char.new('c'),Vedeu::Char.new('.'),Vedeu::Char.new('.'),
+                Vedeu::Char.new('.')
+              ],[
+                Vedeu::Char.new('-'),Vedeu::Char.new('.'),Vedeu::Char.new('Z'),
+                Vedeu::Char.new('n'),Vedeu::Char.new('.'),Vedeu::Char.new('1'),
+                Vedeu::Char.new('2')
+              ],[
+                Vedeu::Char.new('S'),Vedeu::Char.new('p'),Vedeu::Char.new('e'),
+                Vedeu::Char.new('l'),Vedeu::Char.new('t'),Vedeu::Char.new('e'),
+                Vedeu::Char.new('r')
+              ],[
+                Vedeu::Char.new('.'),Vedeu::Char.new('.'),Vedeu::Char.new('M'),
+                Vedeu::Char.new('e'),Vedeu::Char.new('t'),Vedeu::Char.new('a'),
+                Vedeu::Char.new('l')
+              ],
+            ]
+          }
+          let(:height) { 3 }
+          let(:width) { 5 }
+          let(:expected) {
+            data[0, height].map { |line| line[0, width] }
+          }
+
+          it { subject.must_equal(expected) }
+        end
+      end
+
+      context 'when the data is not larger than the visible area' do
+        context 'when the data is a String' do
+          let(:data) {
+            "Gallium is a chemical element with\n" \
+            "symbol Ga and atomic number 31.\n"
+          }
+
+          it { subject.must_equal(
+            [
+              "Gallium is a chemical element with",
+              "symbol Ga and atomic number 31."
+            ])
+          }
+        end
+
+        context 'when the data is an Array' do
+          # Gallium
+          # -.Ga.31
+          let(:data) {
+            [
+              [
+                Vedeu::Char.new('G'),Vedeu::Char.new('a'),Vedeu::Char.new('l'),
+                Vedeu::Char.new('l'),Vedeu::Char.new('i'),Vedeu::Char.new('u'),
+                Vedeu::Char.new('m')
+              ], [
+                Vedeu::Char.new('-'),Vedeu::Char.new('.'),Vedeu::Char.new('G'),
+                Vedeu::Char.new('a'),Vedeu::Char.new('.'),Vedeu::Char.new('3'),
+                Vedeu::Char.new('1')
+              ]
+            ]
+          }
+          let(:height) { 3 }
+          let(:width) { 10 }
+
+          it { subject.must_equal(data) }
+        end
+      end
+
+      context 'when there is no data' do
+        let(:data) {}
+
+        it { subject.must_equal([]) }
+      end
+    end
+
+    describe '#print' do
+      let(:string) {}
+
+      subject { instance.print(string) }
+
+      it { subject.must_be_instance_of(Array) }
+    end
+
+  end # Write
+
+end # Vedeu

data/test/lib/vedeu/traps_test.rb

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

data/test/lib/vedeu_test.rb

@@ -1,5 +1,7 @@
 require 'test_helper'
 
 describe Vedeu do
+
   # ...
+
 end # Vedeu