vedeu 0.0.25 → 0.0.26

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

@@ -0,0 +1,22 @@
+require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/models/style_collection'
+require_relative '../../../../lib/vedeu/models/stream'
+
+module Vedeu
+  describe StyleCollection do
+    let(:described_class) { StyleCollection }
+
+    describe '#coerce' do
+      let(:subject) { Vedeu::Stream.new({ style: style }).style }
+      let(:style)   {}
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an empty string' do
+        subject.must_equal('')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/output/interface_renderer'
+require_relative '../../../../lib/vedeu/models/interface'
+
+module Vedeu
+  describe InterfaceRenderer do
+    let(:described_class)    { InterfaceRenderer }
+    let(:described_instance) { described_class.new(interface) }
+    let(:interface)          { }
+
+  end
+end

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

@@ -1,51 +1,36 @@
 require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/output/output'
 
 module Vedeu
   describe Output do
     let(:described_class) { Output }
-    let(:subject)         { described_class.new }
     let(:output)          {}
 
     before do
-      InterfaceRepository.create({ name: 'dummy', width: 15, height: 2, cursor: true })
+      InterfaceRepository.create({
+        name: 'dummy',
+        width: 15,
+        height: 2,
+        cursor: true
+      })
       Terminal.stubs(:output).returns(output)
     end
 
     after { InterfaceRepository.reset }
 
-    it 'returns an Output instance' do
-      subject.must_be_instance_of(Output)
+    describe '#initialize' do
+      let(:subject) { described_class.new }
+
+      it 'returns an Output instance' do
+        subject.must_be_instance_of(Output)
+      end
     end
 
     describe '.render' do
       let(:subject) { described_class.render }
 
-      context 'when the interfaces have content' do
-        let(:output) {
-          [
-            [
-              "\e[38;2;39m\e[48;2;49m\e[1;1H               \e[1;1HTesting Outpu...\e[38;2;39m\e[48;2;49m\e[?25h",
-              "\e[38;2;39m\e[48;2;49m\e[2;1H               \e[2;1H\e[38;2;39m\e[48;2;49m\e[?25h"
-            ]
-          ]
-        }
-
-        before { Compositor.arrange({ 'dummy' => [[{ text: 'Testing Output.render' }]] }) }
-
-        it { subject.must_equal(output) }
-      end
-
-      context 'when the interfaces have no content' do
-        let(:output) {
-          [
-            [
-              "\e[38;2;39m\e[48;2;49m\e[1;1H               \e[1;1H\e[38;2;39m\e[48;2;49m\e[?25h",
-              "\e[38;2;39m\e[48;2;49m\e[2;1H               \e[2;1H\e[38;2;39m\e[48;2;49m\e[?25h"
-            ]
-          ]
-        }
-
-        it { subject.must_equal(output) }
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
       end
     end
   end

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

@@ -1,27 +1,37 @@
 require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/process/process'
+require_relative '../../../../lib/vedeu/repository/interface_repository'
 
 module Vedeu
   describe Process do
     let(:described_class) { Process }
     let(:input)           { nil }
     let(:result)          {}
-    let(:subject)         { described_class.new }
 
-    it 'returns a Process instance' do
-      subject.must_be_instance_of(Process)
+    describe '#initialize' do
+      let(:subject) { described_class.new }
+
+      it 'returns a Process instance' do
+        subject.must_be_instance_of(Process)
+      end
     end
 
     describe '.evaluate' do
       let(:subject) { described_class.evaluate }
       let(:command) { Command.new }
+      let(:json)    { {} }
 
       before do
-        InterfaceRepository.create({ name: 'dummy', width: 15, height: 2 })
+        InterfaceRepository.create({
+          name: 'dummy',
+          width: 15,
+          height: 2
+        })
         Queue.stubs(:dequeue).returns(input)
-        CommandRepository.stubs(:by_keypress).returns(command)
-        CommandRepository.stubs(:by_keyword).returns(command)
+        CommandRepository.stubs(:by_input).returns(command)
         command.stubs(:execute).returns(result)
-        Compositor.stubs(:arrange).returns([])
+        Parser.stubs(:parse).returns(json)
+        Composition.stubs(:enqueue).returns([])
       end
 
       after do
@@ -30,61 +40,29 @@ module Vedeu
       end
 
       context 'when there is no input' do
-        it 'returns a NilClass' do
-          subject.must_be_instance_of(NilClass)
+        it 'raises an exception' do
+          proc { subject }.must_raise(StopIteration)
         end
       end
 
-      context 'when the input is a keypress' do
+      context 'when there is input' do
         let(:input) { "q" }
 
-        context 'but there is no result' do
-          it 'returns a NilClass' do
-            subject.must_be_instance_of(NilClass)
-          end
-        end
-
-        context 'or the result is :stop' do
-          let(:result) { :stop }
-
-          it 'raises an exception' do
-            proc { subject }.must_raise(StopIteration)
-          end
-        end
-
-        context 'or the result is anything else' do
+        context 'and there is a result' do
           let(:result) { { 'dummy' => [['output...']] } }
 
           it 'returns an Array' do
             subject.must_be_instance_of(Array)
           end
         end
-      end
-
-      context 'when the input is a keyword' do
-        let(:input) { "quit" }
-
-        context 'but there is no result' do
-          it 'returns a NilClass' do
-            subject.must_be_instance_of(NilClass)
-          end
-        end
 
-        context 'or the result is :stop' do
+        context 'or there is no result or the result is :stop' do
           let(:result) { :stop }
 
           it 'raises an exception' do
             proc { subject }.must_raise(StopIteration)
           end
         end
-
-        context 'or the result is anything else' do
-          let(:result) { { 'dummy' => [['output...']] } }
-
-          it 'returns an Array' do
-            subject.must_be_instance_of(Array)
-          end
-        end
       end
     end
   end

data/test/lib/vedeu/repository/command_repository_test.rb

@@ -1,4 +1,6 @@
 require_relative '../../../test_helper'
+require_relative '../../../support/dummy_command'
+require_relative '../../../../lib/vedeu/repository/command_repository'
 
 module Vedeu
   describe CommandRepository do
@@ -22,16 +24,15 @@ module Vedeu
 
     after { CommandRepository.reset }
 
-    describe '.by_keypress' do
-      let(:subject) { described_class.by_keypress(input) }
+    describe '.by_input' do
+      let(:subject) { described_class.by_input(input) }
+      let(:input)   { 'b' }
 
-      context 'when the command was found by keypress' do
-        let(:input) { 'b' }
-
-        it 'returns the Command instance' do
-          subject.must_be_instance_of(Command)
-        end
+      it 'returns the Command instance' do
+        subject.must_be_instance_of(Command)
+      end
 
+      context 'when the command was found by keypress' do
         it 'returns the correct command' do
           subject.name.must_equal('banana')
         end
@@ -44,18 +45,10 @@ module Vedeu
           subject.keypress.must_equal('b')
         end
       end
-    end
-
-    describe '.by_keyword' do
-      let(:subject) { described_class.by_keyword(input) }
 
       context 'when the command was found by keyword' do
         let(:input) { 'apple' }
 
-        it 'returns the Command instance' do
-          subject.must_be_instance_of(Command)
-        end
-
         it 'returns the correct command' do
           subject.keypress.must_equal('a')
         end
@@ -70,9 +63,22 @@ module Vedeu
       end
     end
 
+    describe '.create' do
+      let(:subject)    { described_class.create(attributes) }
+      let(:attributes) { {} }
+
+      it 'returns a Command' do
+        subject.must_be_instance_of(Command)
+      end
+    end
+
     describe '.entity' do
       let(:subject) { described_class.entity }
 
+      it 'returns a Class instance' do
+        subject.must_be_instance_of(Class)
+      end
+
       it 'returns Command' do
         subject.must_equal(Command)
       end

data/test/lib/vedeu/repository/interface_repository_test.rb

@@ -1,11 +1,33 @@
 require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/repository/interface_repository'
 
 module Vedeu
   describe InterfaceRepository do
     let(:described_class) { InterfaceRepository }
 
-    before { InterfaceRepository.create({ name: 'dummy', width: 15, height: 2 }) }
-    after  { InterfaceRepository.reset }
+    before do
+      InterfaceRepository.create({
+        name: 'dummy',
+        width: 15,
+        height: 2
+      })
+    end
+    after { InterfaceRepository.reset }
+
+    describe '.create' do
+      let(:subject)    { described_class.create(attributes) }
+      let(:attributes) {
+        {
+          name: 'dummy',
+          width: 15,
+          height: 2
+        }
+      }
+
+      it 'returns an Interface' do
+        subject.must_be_instance_of(Interface)
+      end
+    end
 
     describe '.find' do
       let(:subject) { described_class.find(value) }
@@ -26,21 +48,35 @@ module Vedeu
       end
     end
 
-    describe '.refresh' do
-      let(:subject) { described_class.refresh }
+    describe '.update' do
+      let(:subject)    { described_class.update(value, attributes) }
+      let(:value)      { 'dummy' }
+      let(:attributes) { { name: 'dumber' } }
 
-      before { Compositor.stubs(:arrange) }
+      it 'returns an Interface' do
+        subject.must_be_instance_of(Interface)
+      end
 
-      it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+      context 'when the interface exists' do
+        it 'updates and returns the existing interface' do
+          subject.name.must_equal('dumber')
+        end
+      end
+
+      context 'when the interface does not exist' do
+        before { InterfaceRepository.reset }
+
+        it 'returns the created interface' do
+          subject.name.must_equal('dumber')
+        end
       end
     end
 
-    describe '.entity' do
-      let(:subject) { described_class.entity }
+    describe '.refresh' do
+      let(:subject) { described_class.refresh }
 
-      it 'returns an Interface' do
-        subject.must_equal(Interface)
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
       end
     end
 
@@ -49,9 +85,9 @@ module Vedeu
 
       before do
         InterfaceRepository.reset
-        @case_a = InterfaceRepository.create({ name: 'a', width: 15, height: 2, layer: 1 })
-        @case_b = InterfaceRepository.create({ name: 'b', width: 15, height: 2, layer: 0 })
-        @case_c = InterfaceRepository.create({ name: 'c', width: 15, height: 2, layer: 2 })
+        @case_a = InterfaceRepository.create({ name: 'a', width: 15, height: 2, z: 2 })
+        @case_b = InterfaceRepository.create({ name: 'b', width: 15, height: 2, z: 1 })
+        @case_c = InterfaceRepository.create({ name: 'c', width: 15, height: 2, z: 3 })
       end
       after  { InterfaceRepository.reset }
 
@@ -63,5 +99,17 @@ module Vedeu
         subject.must_equal([@case_b, @case_a, @case_c])
       end
     end
+
+    describe '.entity' do
+      let(:subject) { described_class.entity }
+
+      it 'returns a Class instance' do
+        subject.must_be_instance_of(Class)
+      end
+
+      it 'returns Interface' do
+        subject.must_equal(Interface)
+      end
+    end
   end
 end

data/test/lib/vedeu/repository/repository_test.rb

@@ -1,4 +1,5 @@
 require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/repository/repository'
 
 module Vedeu
   class Dummy

data/test/lib/vedeu/repository/storage_test.rb

@@ -1,18 +1,25 @@
 require_relative '../../../test_helper'
+require_relative '../../../support/dummy_command'
+require_relative '../../../../lib/vedeu/repository/storage'
+
 
 module Vedeu
   describe Storage do
     let(:described_class) { Storage }
     let(:subject)         { described_class.new }
     let(:record)          { DummyCommand.new }
-    let(:entity)           {}
+    let(:entity)          {}
 
-    it 'returns a Storage instance' do
-      subject.must_be_instance_of(Storage)
-    end
+    describe '#initialize' do
+      let(:subject) { described_class.new }
 
-    it 'sets an instance variable' do
-      subject.instance_variable_get('@map').must_equal({})
+      it 'returns a Storage instance' do
+        subject.must_be_instance_of(Storage)
+      end
+
+      it 'sets an instance variable' do
+        subject.instance_variable_get('@map').must_equal({})
+      end
     end
 
     describe '#create' do

data/test/lib/vedeu/{output → support}/cursor_test.rb

@@ -1,4 +1,5 @@
 require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/support/cursor'
 
 module Vedeu
   describe Cursor do

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

@@ -0,0 +1,348 @@
+require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/support/esc'
+
+module Vedeu
+  describe Esc do
+    let(:described_class) { Esc }
+
+    describe '.background_colour' do
+      let(:subject) { described_class.background_colour }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[48;5;16m")
+      end
+    end
+
+    describe '.blink' do
+      let(:subject) { described_class.blink }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[5m")
+      end
+    end
+
+    describe '.blink_off' do
+      let(:subject) { described_class.blink_off }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[25m")
+      end
+    end
+
+    describe '.bold' do
+      let(:subject) { described_class.bold }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[1m")
+      end
+    end
+
+    describe '.bold_off' do
+      let(:subject) { described_class.bold_off }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[21m")
+      end
+    end
+
+    describe '.clear' do
+      let(:subject) { described_class.clear }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[2J")
+      end
+    end
+
+    describe '.clear_line' do
+      let(:subject) { described_class.clear_line }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[2K")
+      end
+    end
+
+    describe '.esc' do
+      let(:subject) { described_class.esc }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[")
+      end
+    end
+
+    describe '.foreground_colour' do
+      let(:subject) { described_class.foreground_colour }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[38;5;231m")
+      end
+    end
+
+    describe '.negative' do
+      let(:subject) { described_class.negative }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[7m")
+      end
+    end
+
+    describe '.positive' do
+      let(:subject) { described_class.positive }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[27m")
+      end
+    end
+
+    describe '.normal' do
+      let(:subject) { described_class.normal }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[24m\e[21m\e[27m")
+      end
+    end
+
+    describe '.dim' do
+      let(:subject) { described_class.dim }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[2m")
+      end
+    end
+
+    describe '.reset' do
+      let(:subject) { described_class.reset }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[0m")
+      end
+    end
+
+    describe '.set_position' do
+      let(:subject) { described_class.set_position(y, x) }
+      let(:y)       {}
+      let(:x)       {}
+
+      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 }
+
+        it 'returns a position escape sequence' do
+          subject.must_equal("\e[12;19H")
+        end
+      end
+    end
+
+    describe '.stylize' do
+      let(:subject) { described_class.stylize(style) }
+      let(:style)   {}
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      context 'when the style is not provided' do
+        it 'returns an empty string' do
+          subject.must_equal('')
+        end
+      end
+
+      context 'when the style is blink' do
+        let(:style) { 'blink' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[5m")
+        end
+      end
+
+      context 'when the style is blink off' do
+        let(:style) { 'blink_off' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[25m")
+        end
+      end
+
+      context 'when the style is bold' do
+        let(:style) { 'bold' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[1m")
+        end
+      end
+
+      context 'when the style is bold off' do
+        let(:style) { 'bold_off' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[21m")
+        end
+      end
+
+      context 'when the style is clear' do
+        let(:style) { 'clear' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[2J")
+        end
+      end
+
+      context 'when the style is hide_cursor' do
+        let(:style) { 'hide_cursor' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[?25l")
+        end
+      end
+
+      context 'when the style is negative' do
+        let(:style) { 'negative' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[7m")
+        end
+      end
+
+      context 'when the style is positive' do
+        let(:style) { 'positive' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[27m")
+        end
+      end
+
+      context 'when the style is reset' do
+        let(:style) { 'reset' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[0m")
+        end
+      end
+
+      context 'when the style is normal' do
+        let(:style) { 'normal' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[24m\e[21m\e[27m")
+        end
+      end
+
+      context 'when the style is dim' do
+        let(:style) { 'dim' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[2m")
+        end
+      end
+
+      context 'when the style is show_cursor' do
+        let(:style) { 'show_cursor' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[?25h")
+        end
+      end
+
+      context 'when the style is underline' do
+        let(:style) { 'underline' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[4m")
+        end
+      end
+
+      context 'when the style is underline off' do
+        let(:style) { 'underline_off' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[24m")
+        end
+      end
+    end
+
+    describe '.underline' do
+      let(:subject) { described_class.underline }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[4m")
+      end
+    end
+
+    describe '.underline_off' do
+      let(:subject) { described_class.underline_off }
+
+      it 'returns a String' do
+        subject.must_be_instance_of(String)
+      end
+
+      it 'returns an escape sequence' do
+        subject.must_equal("\e[24m")
+      end
+    end
+  end
+end