vedeu 0.0.30 → 0.0.31

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

@@ -3,73 +3,35 @@ require_relative '../../../../lib/vedeu/models/stream'
 
 module Vedeu
   describe Stream do
-    let(:described_class)    { Stream }
-    let(:described_instance) { described_class.new(attributes) }
-    let(:attributes)         {
-      {
-        style:  'normal',
-        colour: { foreground: '#ff0000', background: '#000000' },
-        text:   'Some text'
-      }
-    }
-
-    describe '#initialize' do
-      let(:subject) { described_instance }
-
-      it 'returns a Stream instance' do
-        subject.must_be_instance_of(Stream)
-      end
+    it 'has a colour attribute' do
+      Stream.new({ colour: { foreground: '#ff0000', background: '#000000' } }).colour.must_be_instance_of(Colour)
     end
 
-    describe '#colour' do
-      let(:subject) { described_instance.colour }
-
-      it 'has a colour attribute' do
-        subject.must_be_instance_of(Colour)
-      end
-    end
-
-    describe '#text' do
-      let(:subject) { described_instance.text }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
-      it 'has a text attribute' do
-        subject.must_equal('Some text')
-      end
+    it 'has a text attribute' do
+      Stream.new({ text: 'Some text' }).text.must_equal('Some text')
     end
 
-    describe '#style' do
-      let(:subject) { described_instance.style }
-
-      it 'has a style attribute' do
-        subject.must_be_instance_of(String)
-      end
+    it 'has a style attribute' do
+      Stream.new({ style: 'normal' }).style.must_equal("\e[24m\e[21m\e[27m")
     end
 
     describe '#to_s' do
-      let(:subject) { described_instance.to_s }
-
       it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
-      it 'returns a String' do
-        subject.must_equal("\e[38;5;196m\e[48;5;16m\e[24m\e[21m\e[27mSome text")
+        Stream.new({
+          style:  'normal',
+          colour: { foreground: '#ff0000', background: '#000000' },
+          text:   'Some text'
+        }).to_s.must_equal("\e[38;5;196m\e[48;5;16m\e[24m\e[21m\e[27mSome text")
       end
     end
 
     describe '#to_json' do
-      let(:subject) { described_instance.to_json }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns a String' do
-        subject.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\\u001b[24m\\u001b[21m\\u001b[27m\",\"text\":\"Some text\"}")
+        Stream.new({
+          style:  'normal',
+          colour: { foreground: '#ff0000', background: '#000000' },
+          text:   'Some text'
+        }).to_json.must_equal("{\"colour\":{\"foreground\":\"\\u001b[38;5;196m\",\"background\":\"\\u001b[48;5;16m\"},\"style\":\"\\u001b[24m\\u001b[21m\\u001b[27m\",\"text\":\"Some text\"}")
       end
     end
   end

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

@@ -4,18 +4,9 @@ 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('')
+        Stream.new({ style: {} }).style.must_equal('')
       end
     end
   end

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

@@ -4,53 +4,22 @@ require_relative '../../../../lib/vedeu/models/interface'
 
 module Vedeu
   describe InterfaceRenderer do
-    let(:described_class)    { InterfaceRenderer }
-    let(:described_instance) { described_class.new(interface) }
-    let(:interface)          { Interface.new(attributes) }
-    let(:attributes)         { { name: 'dummy', width: 20, height: 2 } }
-
-    describe '#initialize' do
-      let(:subject) { described_instance }
-
-      it 'returns an InterfaceRenderer instance' do
-        subject.must_be_instance_of(InterfaceRenderer)
-      end
-
-      it 'sets an instance variable' do
-        subject.instance_variable_get("@interface").must_equal(interface)
-      end
-    end
-
     describe '.clear' do
-      let(:subject) { described_class.clear(interface) }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns the escape sequence to clear the whole interface' do
-        subject.must_equal("\e[1;1H                    \e[1;1H\e[2;1H                    \e[2;1H")
+        interface = Interface.new({ name: 'dummy', width: 20, height: 2 })
+        InterfaceRenderer.clear(interface).must_equal("\e[1;1H                    \e[1;1H\e[2;1H                    \e[2;1H")
       end
 
-      context 'when the interface has colour attributes' do
-        let(:attributes) { { name: 'dummy', width: 20, height: 2, colour: { foreground: '#00ff00', background: '#ffff00' } } }
-
-        it 'returns the escape sequence to clear the whole interface' do
-          subject.must_equal("\e[38;5;46m\e[48;5;226m\e[1;1H                    \e[1;1H\e[2;1H                    \e[2;1H")
-        end
+      it 'returns the escape sequence to clear the whole interface with specified colours' do
+        interface = Interface.new({ name: 'dummy', width: 20, height: 2, colour: { foreground: '#00ff00', background: '#ffff00' } })
+        InterfaceRenderer.clear(interface).must_equal("\e[38;5;46m\e[48;5;226m\e[1;1H                    \e[1;1H\e[2;1H                    \e[2;1H")
       end
     end
 
     describe '.render' do
-      let(:subject)    { described_class.render(interface) }
-      let(:attributes) { { name: 'dummy', width: 20, height: 2, lines: "Some text..." } }
-
-      it 'returns a String' do
-        subject.must_be_instance_of(String)
-      end
-
       it 'returns the content for the interface' do
-        subject.must_equal("\e[1;1HSome text...")
+        interface = Interface.new({ name: 'dummy', width: 20, height: 2, lines: 'InterfaceRenderer.render' })
+        InterfaceRenderer.render(interface).must_equal("\e[1;1HInterfaceRenderer.render")
       end
     end
   end

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

@@ -3,26 +3,9 @@ require_relative '../../../../lib/vedeu/output/output'
 
 module Vedeu
   describe Output do
-    let(:described_module) { Output }
-    let(:output)           {}
-
-    before do
-      InterfaceRepository.create({
-        name: 'dummy',
-        width: 15,
-        height: 2,
-        cursor: true
-      })
-      Terminal.stubs(:output).returns(output)
-    end
-
-    after { InterfaceRepository.reset }
-
     describe '.render' do
-      let(:subject) { described_module.render }
-
       it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+        Output.render.must_be_instance_of(Array)
       end
     end
   end

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

@@ -0,0 +1,20 @@
+require_relative '../../../test_helper'
+
+module Vedeu
+  describe Template do
+    describe '#parse' do
+      object = OpenStruct.new(value: 'Hello from variable!')
+
+      it 'parses the template when the template file was found' do
+        path   = '/../../../test/support/template.erb'
+        Template.new(object, path).parse.must_match(/This is the test template/)
+        Template.new(object, path).parse.must_match(/Hello from variable!/)
+      end
+
+      it 'raises an exception when the template file cannot be found' do
+        path   = '/some/wrong/path/template.erb'
+        proc { Template.new(object, path).parse }.must_raise(Errno::ENOENT)
+      end
+    end
+  end
+end

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

@@ -3,57 +3,20 @@ require_relative '../../../../lib/vedeu/output/text_adaptor'
 
 module Vedeu
   describe TextAdaptor do
-    let(:described_class) { TextAdaptor }
-    let(:text)            { '' }
-
-    describe '#initialize' do
-      let(:subject) { described_class.new(text) }
-
-      it 'returns an TextAdaptor instance' do
-        subject.must_be_instance_of(TextAdaptor)
-      end
-
-      it 'sets an instance variable' do
-        subject.instance_variable_get('@text').must_equal(text)
-      end
-    end
-
     describe '.adapt' do
-      let(:subject) { described_class.adapt(text) }
-
-      it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+      it 'returns an empty collection when processing an empty string' do
+        TextAdaptor.adapt('').must_be_empty
       end
 
-      context 'when processing an empty string' do
-        let(:text) { '' }
-
-        it 'returns an empty collection' do
-          subject.must_be_empty
-        end
+      it 'returns a single line' do
+        text = "This is a single line of text.\n"
+        TextAdaptor.adapt(text).size.must_equal(1)
       end
 
-      context 'when processing a single line' do
-        let(:text) { "This is a single line of text.\n" }
-
-        it 'returns a collection of Line objects' do
-          subject.first.must_be_instance_of(Line)
-
-          subject.size.must_equal(1)
-        end
-      end
-
-      context 'when processing multiple lines' do
-        let(:text) {
-          "Lorem ipsum dolor sit amet,\nConseactetur adipiscing.\n" \
-          "Curabitur aliquet, turpis id dui.\n\nConditum elemum.\n"
-        }
-
-        it 'returns a collection of Line objects' do
-          subject.first.must_be_instance_of(Line)
-
-          subject.size.must_equal(5)
-        end
+      it 'returns multiple lines' do
+        text = "Lorem ipm olor sit aet,\nConsctetur adipiscing.\n" \
+               "Curitur aiquet, trpis id dui.\n\nCondum elemum.\n"
+        TextAdaptor.adapt(text).size.must_equal(5)
       end
     end
   end

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

@@ -1,71 +1,69 @@
 require_relative '../../../test_helper'
 require_relative '../../../../lib/vedeu/process/process'
-# require_relative '../../../../lib/vedeu/repository/interface_repository'
 require_relative '../../../support/dummy_command'
 require_relative '../../../../lib/vedeu/repository/command_repository'
 
 module Vedeu
   class QuitCommand
-    def self.dispatch(*args)
+    def self.dispatch
       :stop
     end
   end
 
   class TestCommand
-    def self.dispatch(*args)
-      :test
+    def self.dispatch
+      {
+        'Process#evaluate' => 'TestCommand.dispatch'
+      }
     end
   end
 
-  describe Process do
-    let(:described_class) { Process }
+  class NoResultCommand
+    def self.dispatch
+    end
+  end
 
+  describe Process do
     describe '.evaluate' do
-      let(:subject) { described_class.evaluate }
+      it 'returns false when there is no input' do
+        Queue.reset
+        Process.evaluate.must_be_instance_of(FalseClass)
+      end
 
-      before do
+      it 'raises an exception when the result is :stop' do
+        CommandRepository.reset
         CommandRepository.create({
-          'name' =>     'quit',
+          name:     'quit',
           entity:   QuitCommand,
           keypress: 'q'
         })
+        Queue.reset
+        Queue.enqueue('q')
+        proc { Process.evaluate }.must_raise(StopIteration)
+      end
+
+      it 'returns an Composition when there is a result' do
+        CommandRepository.reset
         CommandRepository.create({
           name:     'test',
           entity:   TestCommand,
           keypress: 't'
         })
-        Queue.stubs(:dequeue).returns(input)
-        Parser.stubs(:parse).returns(Composition.new)
+        Queue.reset
+        Queue.enqueue('t')
+        Process.evaluate.must_be_instance_of(Composition)
       end
 
-      after do
+      it 'returns a NilClass when there is no result' do
         CommandRepository.reset
-      end
-
-      context 'when there is no input' do
-        let(:input) { '' }
-
-        it 'returns a FalseClass' do
-          subject.must_be_instance_of(FalseClass)
-        end
-      end
-
-      context 'when there is input' do
-        context 'and the result is :stop' do
-          let(:input) { 'q' }
-
-          it 'raises an exception' do
-            proc { subject }.must_raise(StopIteration)
-          end
-        end
-
-        context 'and there is a result' do
-          let(:input) { 't' }
-
-          it 'returns an Composition' do
-            subject.must_be_instance_of(Composition)
-          end
-        end
+        CommandRepository.create({
+          name:     'no_result',
+          entity:   NoResultCommand,
+          keypress: 'n'
+        })
+        Queue.reset
+        Queue.enqueue('n')
+        Process.evaluate.must_be_instance_of(NilClass)
       end
     end
   end

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

@@ -4,9 +4,6 @@ require_relative '../../../../lib/vedeu/repository/command_repository'
 
 module Vedeu
   describe CommandRepository do
-    let(:described_class) { CommandRepository }
-    let(:input)           {}
-
     before do
       CommandRepository.create({
         name:     'apple',
@@ -21,66 +18,40 @@ module Vedeu
         keyword:  'banana'
       })
     end
-
     after { CommandRepository.reset }
 
     describe '.by_input' do
-      let(:subject) { described_class.by_input(input) }
-      let(:input)   { 'b' }
-
-      it 'returns the Command instance' do
-        subject.must_be_instance_of(Command)
+      it 'returns the correct command when the command was found by keypress' do
+        CommandRepository.by_input('b').name.must_equal('banana')
+        CommandRepository.by_input('b').name.wont_equal('apple')
+        CommandRepository.by_input('b').keypress.must_equal('b')
       end
 
-      context 'when the command was found by keypress' do
-        it 'returns the correct command' do
-          subject.name.must_equal('banana')
-        end
-
-        it 'returns the correct command' do
-          subject.name.wont_equal('apple')
-        end
-
-        it 'returns the correct command' do
-          subject.keypress.must_equal('b')
-        end
+      it 'returns the correct command when the command was found by keyword' do
+        CommandRepository.by_input('apple').keypress.must_equal('a')
+        CommandRepository.by_input('apple').keypress.wont_equal('b')
+        CommandRepository.by_input('apple').name.wont_equal('banana')
       end
 
-      context 'when the command was found by keyword' do
-        let(:input) { 'apple' }
-
-        it 'returns the correct command' do
-          subject.keypress.must_equal('a')
-        end
-
-        it 'returns the correct command' do
-          subject.keypress.wont_equal('b')
-        end
+      it 'returns FalseClass when no command was found' do
+        CommandRepository.by_input('not_found').must_be_instance_of(FalseClass)
+      end
 
-        it 'returns the correct command' do
-          subject.name.wont_equal('banana')
-        end
+      it 'returns FalseClass when there is no input' do
+        CommandRepository.by_input('').must_be_instance_of(FalseClass)
       end
     end
 
     describe '.create' do
-      let(:subject)    { described_class.create(attributes) }
-      let(:attributes) { {} }
-
       it 'returns a Command' do
-        subject.must_be_instance_of(Command)
+        skip
+        CommandRepository.create({}).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)
+        CommandRepository.entity.must_equal(Command)
       end
     end
   end

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

@@ -3,112 +3,74 @@ require_relative '../../../../lib/vedeu/repository/interface_repository'
 
 module Vedeu
   describe InterfaceRepository do
-    let(:described_class) { InterfaceRepository }
-
-    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) {
-        {
+      it 'returns an Interface' do
+        InterfaceRepository.create({
           name: 'dummy',
           width: 15,
           height: 2
-        }
-      }
-
-      it 'returns an Interface' do
-        subject.must_be_instance_of(Interface)
+        }).must_be_instance_of(Interface)
       end
     end
 
     describe '.find' do
-      let(:subject) { described_class.find(value) }
-      let(:value)   { 'dummy' }
-
-      context 'when the interface exists' do
-        it 'returns an Interface' do
-          subject.must_be_instance_of(Interface)
-        end
+      it 'returns an Interface when the interface exists' do
+        InterfaceRepository.create({
+          name: 'dummy',
+          width: 15,
+          height: 2
+        })
+        InterfaceRepository.find('dummy').must_be_instance_of(Interface)
       end
 
-      context 'when the interface does not exist' do
-        before { InterfaceRepository.reset }
-
-        it 'raises an exception' do
-          proc { subject }.must_raise(UndefinedInterface)
-        end
+      it 'raises an exception when the interface does not exist' do
+        InterfaceRepository.reset
+        proc { InterfaceRepository.find('dummy') }
+          .must_raise(UndefinedInterface)
       end
     end
 
     describe '.update' do
-      let(:subject)    { described_class.update(value, attributes) }
-      let(:value)      { 'dummy' }
-      let(:attributes) { { name: 'dumber' } }
-
       it 'returns an Interface' do
-        subject.must_be_instance_of(Interface)
+        InterfaceRepository.update('dummy', { name: 'dumber' })
+          .must_be_instance_of(Interface)
       end
 
-      context 'when the interface exists' do
-        it 'updates and returns the existing interface' do
-          subject.name.must_equal('dumber')
-        end
+      it 'updates and returns the existing interface when the interface exists' do
+        InterfaceRepository.update('dummy', { name: 'dumber' }).name
+          .must_equal('dumber')
       end
 
-      context 'when the interface does not exist' do
-        before { InterfaceRepository.reset }
-
-        it 'returns the created interface' do
-          subject.name.must_equal('dumber')
-        end
+      it 'returns a new interface when the interface does not exist' do
+        InterfaceRepository.reset
+        InterfaceRepository.update('dummy', { name: 'dumber' }).name
+          .must_equal('dumber')
       end
     end
 
     describe '.refresh' do
-      let(:subject) { described_class.refresh }
-
-      it 'returns an Array' do
-        subject.must_be_instance_of(Array)
-      end
-    end
-
-    describe '.by_layer' do
-      let(:subject) { described_class.by_layer }
-
-      before do
-        InterfaceRepository.reset
-        @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 }
-
       it 'returns an Array' do
-        subject.must_be_instance_of(Array)
+        InterfaceRepository.refresh.must_be_instance_of(Array)
       end
 
       it 'returns the collection in order they should be drawn' do
-        subject.must_equal([@case_b, @case_a, @case_c])
+        InterfaceRepository.reset
+        InterfaceRepository.create({
+          name: 'a', width: 15, height: 2, z: 2
+        }).enqueue("a")
+        InterfaceRepository.create({
+          name: 'b', width: 15, height: 2, z: 1
+        }).enqueue("b")
+        InterfaceRepository.create({
+          name: 'c', width: 15, height: 2, z: 3
+        }).enqueue("c")
+        InterfaceRepository.refresh.must_equal(['b', 'a', '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)
+        InterfaceRepository.entity.must_equal(Interface)
       end
     end
   end