vedeu 0.0.3 → 0.0.4

data/lib/vedeu/version.rb

@@ -1,3 +1,3 @@
 module Vedeu
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/lib/vedeu/application_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+module Vedeu
+  describe Application do
+    let(:described_class){ Application }
+    let(:instance)   { described_class.new(interfaces, options) }
+    let(:interfaces) {}
+    let(:options)    { {} }
+
+    describe '#start' do
+      before { Esc.stubs(:clear).returns('') }
+
+      subject { instance.start }
+
+      it { skip }
+    end
+  end
+end

data/test/lib/vedeu/interface/interface_test.rb

@@ -0,0 +1,76 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Interface do
+    let(:described_class)    { Interface }
+    let(:instance) { described_class.new(options) }
+    let(:options)  { {} }
+
+    before do
+      Terminal.stubs(:width).returns(80)
+      Terminal.stubs(:height).returns(25)
+      Terminal.stubs(:show_cursor)
+      Terminal.stubs(:hide_cursor)
+    end
+
+    it { instance.must_be_instance_of(Interface) }
+
+    describe '#initial' do
+      subject { instance.initial }
+
+      context 'capturing output' do
+        let(:io) { capture_io { subject }.join }
+
+        it { io.must_be_instance_of(String) }
+      end
+    end
+
+    describe '#main' do
+      subject { instance.main }
+
+      it { subject.must_be_instance_of(NilClass) }
+
+      context 'capturing output' do
+        let(:io) { capture_io { subject }.join }
+
+        it { io.must_be_instance_of(String) }
+      end
+    end
+
+    describe '#input' do
+      subject { instance.input }
+
+      it { subject.must_be_instance_of(NilClass) }
+
+      context 'capturing output' do
+        let(:io) { capture_io { subject }.join }
+
+        it { io.must_be_instance_of(String) }
+      end
+    end
+
+    describe '#output' do
+      subject { instance.output }
+
+      it { subject.must_be_instance_of(NilClass) }
+
+      context 'capturing output' do
+        let(:io) { capture_io { subject }.join }
+
+        it { io.must_be_instance_of(String) }
+      end
+    end
+
+    describe '#width' do
+      subject { instance.width }
+
+      it { subject.must_be_instance_of(Fixnum) }
+    end
+
+    describe '#height' do
+      subject { instance.height }
+
+      it { subject.must_be_instance_of(Fixnum) }
+    end
+  end
+end

data/test/lib/vedeu/interface/interfaces_test.rb

@@ -0,0 +1,63 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Interfaces do
+    let(:described_class)    { Interfaces }
+    let(:instance) { described_class.new }
+    let(:block)    {}
+
+    it { instance.must_be_instance_of(Interfaces) }
+
+    describe '.default' do
+      subject { described_class.default }
+
+      it { subject.must_be_instance_of(Interfaces) }
+
+      it 'adds the dummy interface to the interface list' do
+        subject.show.wont_be_empty
+      end
+    end
+
+    describe '.define' do
+      subject { described_class.define }
+
+      it { subject.must_be_instance_of(Interfaces) }
+    end
+
+    describe '#add' do
+      let(:interface_name)  {}
+      let(:klass) { Class }
+      let(:options)         { {} }
+
+      subject { instance.add(interface_name, klass, options) }
+
+      it { subject.must_be_instance_of(Hash) }
+
+      it { subject.wont_be_empty }
+
+      context 'when the interface class does not exist' do
+        before { Object.stubs(:const_defined?).returns(false) }
+
+        it { proc { subject }.must_raise(UndefinedInterface) }
+      end
+    end
+
+    describe '#show' do
+      subject { instance.show }
+
+      it { subject.must_be_instance_of(Hash) }
+    end
+
+    describe '#initial' do
+      subject { instance.initial }
+
+      it { subject.must_be_instance_of(Array) }
+    end
+
+    describe '#main' do
+      subject { instance.main }
+
+      it { subject.must_be_instance_of(Array) }
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Background do
+    let(:described_class) { Background }
+    let(:instance) { described_class.new }
+
+    it { instance.must_be_instance_of(Background) }
+  end
+end

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

@@ -0,0 +1,10 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Base do
+    let(:described_class) { Base }
+    let(:instance) { described_class.new }
+
+    it { instance.must_be_instance_of(Base) }
+  end
+end

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

@@ -0,0 +1,67 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Colour do
+    let(:described_class)    { Colour }
+    let(:instance) { described_class.new }
+    let(:pair)     { [] }
+
+    it { instance.must_be_instance_of(Colour) }
+
+    describe '.set' do
+      subject { described_class.set(pair) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when the foreground and background are specified as symbols' do
+        context 'when both the foreground and background is specified' do
+          let(:pair) { [:red, :yellow] }
+
+          it 'returns the code for red on yellow' do
+            subject.must_equal("\e[38;5;31m\e[48;5;43m")
+          end
+        end
+
+        context 'when a foreground is specified' do
+          let(:pair) { [:blue] }
+
+          it 'returns the code for blue on default' do
+            subject.must_equal("\e[38;5;34m\e[48;5;49m")
+          end
+        end
+
+        context 'when a background is specified' do
+          let(:pair) { [nil, :cyan] }
+
+          it 'returns the code for default with cyan background' do
+            subject.must_equal("\e[38;5;39m\e[48;5;46m")
+          end
+        end
+
+        context 'when an invalid foreground/background is specified' do
+          let(:pair) { [:melon, :raspberry] }
+
+          it 'returns the default code' do
+            subject.must_equal("\e[38;5;39m\e[48;5;49m")
+          end
+        end
+
+        context 'when no foreground/background is specified' do
+          let(:pair) { [] }
+
+          it 'returns the reset code' do
+            subject.must_equal("\e[38;5;39m\e[48;5;49m")
+          end
+        end
+      end
+
+      context 'when the foreground and background are specified as strings' do
+        let(:pair) { ['#ff0000', '#0000ff'] }
+
+        it 'returns the default code' do
+          subject.must_equal("\e[38;5;196m\e[48;5;21m")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Compositor do
+    let(:described_class)    { Compositor }
+    let(:instance) { described_class.new(rows) }
+    let(:rows)     { [[]] }
+
+    before { Terminal.stubs(:output) }
+
+    it { instance.must_be_instance_of(Compositor) }
+
+    describe '.write' do
+      subject { described_class.write(rows) }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when empty' do
+        let(:rows) { [] }
+
+        it { subject.must_be_instance_of(NilClass) }
+      end
+
+      context 'when unstyled' do
+        context 'and a single line' do
+          let(:rows) { [['Some text...']] }
+
+          it { subject.must_equal('Some text...') }
+        end
+
+        context 'and multi-line' do
+          let(:rows) {
+            [
+              ['Some text...'],
+              ['Some more text...']
+            ]
+          }
+
+          it { subject.must_equal("Some text...\nSome more text...") }
+        end
+      end
+
+      context 'when styled' do
+        context 'with colour pair' do
+          context 'and a single line' do
+            let(:rows) {
+              [
+                [[:red, :white], 'Some text...']
+              ]
+            }
+
+            it { subject.must_equal("\e[38;5;31m\e[48;5;47mSome text...") }
+          end
+
+          context 'and multi-line' do
+            let(:rows) {
+              [
+                [[:red, :white],   'Some text...'],
+                [[:blue, :yellow], 'Some more text...']
+              ]
+            }
+
+            it { subject.must_equal("\e[38;5;31m\e[48;5;47mSome text...\n" \
+                                    "\e[38;5;34m\e[48;5;43mSome more text...") }
+          end
+        end
+
+        context 'with a style' do
+          context 'and a single line' do
+            let(:rows) {
+              [
+                [:bold, 'Some text...']
+              ]
+            }
+
+            it { subject.must_equal("\e[1mSome text...") }
+          end
+
+          context 'and multi-line' do
+            let(:rows) {
+              [
+                [:inverse,   'Some text...'],
+                [:underline, 'Some more text...']
+              ]
+            }
+
+            it { subject.must_equal("\e[7mSome text...\n" \
+                                    "\e[4mSome more text...") }
+          end
+        end
+
+        context 'with an unknown style' do
+          let(:rows) {
+            [
+              [:unknown, 'Some text...']
+            ]
+          }
+
+          it 'renders in the default style' do
+            subject.must_equal("Some text...")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Directive do
+    let(:described_class)     { Directive }
+    let(:instance)  { described_class.new(directive) }
+    let(:directive) {}
+
+    it { instance.must_be_instance_of(Directive) }
+
+    describe '.enact' do
+      subject { described_class.enact(directive) }
+
+      context 'when the directive is invalid' do
+        it 'raises an exception' do
+          proc { subject }.must_raise(InvalidDirective)
+        end
+      end
+
+      context 'when the directive is valid' do
+        context 'when the directive is a collection' do
+          let(:directive) { [] }
+
+          context 'and the first element is a number' do
+            let(:directive) { [0, 0] }
+
+            before { Position.stubs(:set) }
+
+            it 'must be a position' do
+              skip
+            end
+          end
+
+          context 'and the first element is a symbol' do
+            let(:directive) { [:default, :default] }
+
+            before { Colour.stubs(:set) }
+
+            it 'must be a colour' do
+              skip
+            end
+          end
+        end
+
+        context 'when the directive is individual' do
+          let(:directive) { :normal }
+
+          it 'must be a style' do
+            skip
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Esc do
+    let(:described_class)    { Esc }
+
+    describe '.bold' do
+      subject { described_class.bold }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[1m") }
+    end
+
+    describe '.clear' do
+      subject { described_class.clear }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[2J") }
+    end
+
+    describe '.esc' do
+      subject { described_class.esc }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[") }
+    end
+
+    describe '.hide_cursor' do
+      subject { described_class.hide_cursor }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[?25l") }
+    end
+
+    describe '.inverse' do
+      subject { described_class.inverse }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[7m") }
+    end
+
+    describe '.reset' do
+      subject { described_class.reset }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[0m") }
+    end
+
+    describe '.show_cursor' do
+      subject { described_class.show_cursor }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[?25h") }
+    end
+
+    describe '.underline' do
+      subject { described_class.underline }
+
+      it { subject.must_be_instance_of(String) }
+
+      it { subject.must_equal("\e[4m") }
+    end
+  end
+end