vedeu 0.0.3 → 0.0.4

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

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

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

@@ -0,0 +1,33 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Position do
+    let(:described_class)    { Position }
+    let(:instance) { described_class.new }
+
+    it { instance.must_be_instance_of(Position) }
+
+    describe '.set' do
+      subject { described_class.set }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when no coordinates are provided' do
+        it 'returns a position escape sequence' do
+          subject.must_equal("\e[1;1H")
+        end
+      end
+
+      context 'when coordinates are provided' do
+        let(:y) { 12 }
+        let(:x) { 19 }
+
+        subject { described_class.set(y, x) }
+
+        it 'returns a position escape sequence' do
+          subject.must_equal("\e[13;20H")
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,52 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Translator do
+    let(:described_class)       { Translator }
+    let(:instance)    { described_class.new(html_colour) }
+    let(:html_colour) {}
+
+    it { instance.must_be_instance_of(Translator) }
+
+    describe '#translate' do
+      {
+        '#ff0000' => 196, # red
+        '#00ff00' => 46,  # green
+        '#0000ff' => 21,  # blue
+        '#ffffff' => 231, # white
+        '#aadd00' => 148, # lime green
+        '#b94f1c' => 130, # sunset orange
+      }.map do |html_colour, terminal_colour|
+        context 'valid' do
+          it 'translation is performed' do
+            described_class.translate(html_colour).must_be_instance_of(Fixnum)
+
+            described_class.translate(html_colour).must_equal(terminal_colour)
+          end
+        end
+      end
+
+      context 'invalid' do
+        it 'returns nil when not present' do
+          described_class.translate.must_equal(nil)
+        end
+
+        it 'returns nil when the wrong type' do
+          described_class.translate(:wrong_type).must_equal(nil)
+        end
+
+        it 'returns nil when invalid format' do
+          described_class.translate('345678').must_equal(nil)
+        end
+
+        it 'returns nil when invalid format' do
+          described_class.translate('#h11111').must_equal(nil)
+        end
+
+        it 'returns nil when invalid format' do
+          described_class.translate('#1111').must_equal(nil)
+        end
+      end
+    end
+  end
+end

data/test/lib/vedeu/process/command_test.rb

@@ -0,0 +1,54 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  class DummyCommand
+    class << self
+      def dispatch; end
+    end
+  end
+
+  describe Command do
+    let(:described_class)       { Command }
+    let(:instance)    { described_class.new(cmd_name, cmd_klass, cmd_args, cmd_options) }
+    let(:cmd_name)    { "dummy" }
+    let(:cmd_klass)   { DummyCommand }
+    let(:cmd_args)    { [] }
+    let(:cmd_options) { {} }
+
+    it { instance.must_be_instance_of(Command) }
+
+    describe '#define' do
+      subject do
+        described_class.define(cmd_name, cmd_klass, cmd_args, cmd_options)
+      end
+
+      it { subject.must_be_instance_of(Hash) }
+
+      it { subject.wont_be_empty }
+
+      context "when the command name is empty" do
+        let(:cmd_name) { "" }
+
+        it { proc { subject }.must_raise(InvalidCommand) }
+      end
+
+      context "when the command class is empty" do
+        let(:cmd_klass) { "" }
+
+        it { proc { subject }.must_raise(InvalidCommand) }
+      end
+
+      context "when the command class is not defined" do
+        before { Object.stubs(:const_defined?).returns(false) }
+
+        it { proc { subject }.must_raise(InvalidCommand) }
+      end
+
+      context "when the command class doesn't have a .dispatch method" do
+        before { cmd_klass.stubs(:singleton_methods).returns([]) }
+
+        it { proc { subject }.must_raise(InvalidCommand) }
+      end
+    end
+  end
+end

data/test/lib/vedeu/process/commands_test.rb

@@ -0,0 +1,62 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  class DummyCommandKlass
+    def self.dispatch; end
+  end
+
+  describe Commands do
+    let(:described_class)    { Commands }
+    let(:instance) { described_class.instance }
+    let(:block)    {}
+
+    it { instance.must_be_instance_of(Commands) }
+
+    describe '.execute' do
+      subject { described_class.execute }
+
+      it { skip }
+    end
+
+    describe '.list' do
+      subject { described_class.list }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+    describe '#define' do
+      let(:command_name)  { "some_name" }
+      let(:command_klass) { DummyCommandKlass }
+      let(:args)          { [] }
+      let(:options)       { {} }
+
+      subject { instance.define(command_name, command_klass, args, options) }
+
+      it { subject.must_be_instance_of(Hash) }
+    end
+
+    describe '#execute' do
+      subject { instance.execute }
+
+      it { skip }
+    end
+
+    describe '#list' do
+      subject { instance.list }
+
+      it { subject.must_be_instance_of(String) }
+    end
+  end
+
+  describe Exit do
+    let(:described_class)    { Exit }
+
+    describe '.dispatch' do
+      subject { described_class.dispatch }
+
+      it { subject.must_be_instance_of(Symbol) }
+
+      it { subject.must_equal(:stop) }
+    end
+  end
+end

data/test/lib/vedeu/process/process_test.rb

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

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

@@ -0,0 +1,140 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Terminal do
+    let(:described_class)    { Terminal }
+    let(:console)  { stub }
+
+    before do
+      IO.stubs(:console).returns(console)
+      console.stubs(:winsize).returns([25, 80])
+    end
+
+    describe '.input' do
+      before  { console.stubs(:gets).returns("test") }
+
+      subject { described_class.input }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+    describe '.output' do
+      before { console.stubs(:puts).returns("test") }
+
+      subject { described_class.output }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+    describe '.width' do
+      subject { described_class.width }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      it 'returns the width of the terminal' do
+        subject.must_equal(80)
+      end
+    end
+
+    describe '.height' do
+      subject { described_class.height }
+
+      it { subject.must_be_instance_of(Fixnum) }
+
+      it 'returns the height of the terminal' do
+        subject.must_equal(25)
+      end
+    end
+
+    describe '.size' do
+      subject { described_class.size }
+
+      it { subject.must_be_instance_of(Array) }
+
+      it 'returns the width and height of the terminal' do
+        subject.must_equal([25, 80])
+      end
+    end
+
+    describe '.open' do
+      subject { described_class.open }
+
+      it { skip }
+    end
+
+    describe '.close' do
+      subject { described_class.close }
+
+      it { skip }
+    end
+
+    describe '.cooked' do
+      subject { described_class.cooked }
+
+      it { skip }
+    end
+
+    describe '.raw' do
+      subject { described_class.raw }
+
+      it { skip }
+    end
+
+    describe '.console' do
+      subject { described_class.console }
+
+      it { skip }
+    end
+
+    describe '.clear_screen' do
+      before do
+        Esc.stubs(:clear).returns('')
+        console.stubs(:puts)
+      end
+
+      subject { described_class.clear_screen }
+
+      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 '.show_cursor' do
+      before { console.stubs(:puts) }
+
+      subject { described_class.show_cursor }
+
+      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 '.hide_cursor' do
+      before { console.stubs(:puts) }
+
+      subject { described_class.hide_cursor }
+
+      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 '#initial_setup!' do
+      subject { described_class.new.initial_setup! }
+
+      it { skip }
+    end
+  end
+end

data/test/lib/vedeu/version_test.rb

@@ -0,0 +1,9 @@
+require_relative '../../test_helper'
+
+module Vedeu
+  describe VERSION do
+    let(:described_class) { VERSION }
+
+    it { described_class.must_be_instance_of(String) }
+  end
+end

data/test/support/test_app/bin/testapp

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+-> { its -> { a } }
+trap('INT') { exit! }
+
+require_relative '../../../../lib/vedeu'
+
+# define an interface
+# Vedeu::Interfaces.define do |interface|
+#   interface.add("", ...)
+# end
+
+class Fake
+  def self.dispatch
+    puts "Fake dispatched..."
+    [
+      [[:white, :red], "Fake executed...",   :reset],
+      [[:white, :green], "Test executed...", :reset],
+    ]
+  end
+end
+
+# use default interface
+Vedeu::Interfaces.default
+
+# define some commands
+Vedeu::Commands.define do |command|
+  command.add("test", Fake)
+end
+
+# create main loop
+Vedeu::Application.start