vedeu 0.2.10 → 0.2.11

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

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Key do
+
+    let(:input)  { '' }
+    let(:output) { proc { :output } }
+
+    describe '#initialize' do
+      it 'returns a new instance of Key' do
+        Key.new(input, output).must_be_instance_of(Key)
+      end
+    end
+
+    describe '#input' do
+      it 'returns the key defined' do
+        Key.new('a', output).input.must_equal('a')
+      end
+
+      context 'alias method #key' do
+        it { Key.new('a', output).key.must_equal('a') }
+      end
+    end
+
+    describe '#output' do
+    end
+
+    describe '#press' do
+      it 'returns the result of calling the proc' do
+        Key.new(input, output).press.must_equal(:output)
+      end
+
+      it 'returns a :noop when the output is not a proc' do
+        Key.new(input, :output).press.must_equal(:noop)
+      end
+    end
+
+  end # Key
+
+end # Vedeu

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

@@ -3,121 +3,45 @@ require 'test_helper'
 module Vedeu
 
   describe Compositor do
+    let(:interface) {
+      {
+        name: 'indium'
+      }
+    }
+    let(:buffer) {
+      Buffer.new({ name: 'indium' })
+    }
 
     before do
-      Buffers.reset
-      Interfaces.reset
+      Focus.stubs(:cursor).returns("\e[?25l")
       Terminal.console.stubs(:print)
     end
 
-    describe '.render' do
-      before do
-        Vedeu.interface('indium') do
-          width  10
-          height 1
-        end
-      end
-
-      subject { Compositor.render('indium') }
+    describe '#initialize' do
+      subject { Compositor.new(interface, buffer) }
 
-      context 'when the buffer does not exist' do
-        it 'raises an exception' do
-          proc { Compositor.render('') }.must_raise(BufferNotFound)
-        end
+      it 'returns an instance of Compositor' do
+        subject.must_be_instance_of(Compositor)
       end
 
-      context 'when the buffer exists' do
-        it 'returns a Array' do
-          subject.must_be_instance_of(Array)
-        end
-
-        context 'when there is new content' do
-          let(:back) {
-            { name: 'indium', lines: [{ streams: [{ text: 'back' }] }] }
-          }
-
-          before { Buffers.add(back) }
-
-          it 'returns the current/front content' do
-            subject.must_equal([
-              "\e[1;1H          \e[1;1H\e[1;1Hback",
-              "\e[1;1H\e[?25l"
-            ])
-          end
-
-          it 'swaps the new content with the current content' do
-            Buffers.find('indium').back.must_equal(back)
-
-            subject
-
-            Buffers.find('indium').back.must_equal({})
-            Buffers.find('indium').front.must_equal(back)
-          end
-        end
-
-        context 'when there is no new content' do
-          let(:front) {
-            { name: 'indium', lines: [{ streams: [{ text: 'front' }] }] }
-          }
-
-          before do
-            Buffers.add(front)
-            Buffers.find('indium').swap
-          end
-
-          it 'returns the current/front content' do
-            subject.must_equal([
-              "\e[1;1H          \e[1;1H\e[1;1Hfront",
-              "\e[1;1H\e[?25l"
-            ])
-          end
-        end
-
-        context 'when there is no new or current content' do
-          let(:previous) {
-            { name: 'indium', lines: [{ streams: [{ text: 'previous' }] }] }
-          }
-
-          before do
-            Buffers.add(previous)       # puts 'previous' on to 'back'
-            Buffers.find('indium').swap # puts 'back' ('previous') on to 'front'
-            Buffers.find('indium').swap # puts 'front' ('previous') on to 'previous'
-          end
-
-          it 'returns the previous content' do
-            subject.must_equal([
-              "\e[1;1H          \e[1;1H\e[1;1Hprevious",
-              "\e[1;1H\e[?25l"
-            ])
-          end
-        end
-
-        context 'when there is no new, current or previous content' do
-          let(:clear) { { name: 'indium', lines: [] } }
-
-          before { Buffers.add(clear) }
+      it 'assigns the interface' do
+        subject.instance_variable_get("@interface").must_equal(interface)
+      end
 
-          it 'returns the escape sequences to clear the interface' do
-            subject.must_equal(["\e[1;1H          \e[1;1H", "\e[1;1H\e[?25l"])
-          end
-        end
+      it 'assigns the buffer' do
+        subject.instance_variable_get("@buffer").must_equal(buffer)
       end
+    end
 
-      context 'when the interface cannot be found' do
-        before do
-          Interfaces.reset
-          Buffers.add({ name: 'indium' })
-        end
+    describe '#compose' do
+      subject { Compositor.new(interface, buffer).compose }
 
-        it 'raises an exception' do
-          proc { Compositor.render('indium') }.must_raise(InterfaceNotFound)
-        end
+      it 'returns an Array' do
+        subject.must_be_instance_of(Array)
       end
-    end
 
-    describe '#initialize' do
-      it 'returns an instance of Compositor' do
-        Compositor.new('indium').must_be_instance_of(Compositor)
+      it 'returns the updated interface attributes' do
+        subject.must_equal([{}])
       end
     end
 

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

@@ -0,0 +1,108 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Output do
+    # let(:interface) {
+    #   Interface.new({
+    #     name:   'flourine',
+    #     geometry: {
+    #       width:  32,
+    #       height: 3,
+    #     },
+    #     lines:    lines,
+    #     colour:   colour
+    #   })
+    # }
+    # let(:lines) {
+    #   [
+    #     {
+    #       streams: [{ text: 'this is the first' }]
+    #     },
+    #     {
+    #       streams: [{ text: 'this is the second and it is long' }]
+    #     },
+    #     {
+    #       streams: [{ text: 'this is the third, it is even longer and still truncated' }]
+    #     },
+    #     {
+    #       streams: [{ text: 'this should not render' }]
+    #     }
+    #   ]
+    # }
+    # let(:colour) { {} }
+
+    # before do
+    #   Buffers.reset
+    #   Cursors.reset
+    #   Interfaces.reset
+
+    #   Terminal.console.stubs(:winsize).returns([5, 40])
+    #   Terminal.console.stubs(:print)
+    # end
+
+    # describe '#initialize' do
+    #   it 'returns an instance of itself' do
+    #     Output.new(interface).must_be_instance_of(Output)
+    #   end
+    # end
+
+    # describe '.render' do
+    #   it 'returns the content for the interface' do
+    #     Output.render(interface).must_equal(
+    #       "\e[1;1H                                \e[1;1H" \
+    #       "\e[2;1H                                \e[2;1H" \
+    #       "\e[3;1H                                \e[3;1H" \
+    #       "\e[1;1Hthis is the first" \
+    #       "\e[2;1Hthis is the second and it is lon" \
+    #       "\e[3;1Hthis is the third, it is even lo"
+    #     )
+    #   end
+
+    #   context 'when there are no streams of text' do
+    #     let(:lines) { [] }
+
+    #     it 'returns a blank interface' do
+    #       Output.render(interface).must_equal(
+    #         "\e[1;1H                                \e[1;1H" \
+    #         "\e[2;1H                                \e[2;1H" \
+    #         "\e[3;1H                                \e[3;1H"
+    #       )
+    #     end
+    #   end
+
+    #   context 'when lines have streams which are empty' do
+    #     let(:lines) {
+    #       [
+    #         {
+    #           streams: [{ text: 'this is the first' }]
+    #         }, {
+    #           streams: { text: '' }
+    #         }, {
+    #           streams: [
+    #             { text: 'this is the third, ' },
+    #             { text: 'it is even longer '  },
+    #             { text: 'and still truncated' }
+    #           ]
+    #         }, {
+    #           streams: [{ text: 'this should not render' }]
+    #         }
+    #       ]
+    #     }
+
+    #     it 'skips lines' do
+    #       Output.render(interface).must_equal(
+    #         "\e[1;1H                                \e[1;1H" \
+    #         "\e[2;1H                                \e[2;1H" \
+    #         "\e[3;1H                                \e[3;1H" \
+    #         "\e[1;1Hthis is the first" \
+    #         "\e[2;1H" \
+    #         "\e[3;1Hthis is the third, it is even lo"
+    #       )
+    #     end
+    #   end
+    # end
+
+  end # Output
+
+end # Vedeu

data/test/lib/vedeu/repositories/buffers_test.rb

@@ -32,14 +32,6 @@ module Vedeu
       end
     end
 
-    describe '.update' do
-      let(:buffer) { Buffer.new({ name: 'einsteinium' }) }
-
-      subject { Buffers.update(buffer) }
-
-      it { subject.must_equal(true) }
-    end
-
   end # Buffers
 
 end # Vedeu

data/test/lib/vedeu/repositories/cursors_test.rb

@@ -6,9 +6,43 @@ module Vedeu
 
     before do
       Cursors.reset
+      Offsets.reset
       Registrar.record({ name: 'chromium' })
     end
 
+    describe '#add' do
+      let(:attributes) { { name: 'chromium' } }
+
+      it 'raises an exception if a :name attribute is not provided' do
+        proc { Offsets.add({ no_name: 'no_name' }) }
+          .must_raise(MissingRequired)
+      end
+
+      it 'returns a new instance of Offset once stored' do
+        Offsets.add({ name: 'praseodymium' }).must_be_instance_of(Offset)
+      end
+
+      it 'returns a new Cursor after registering' do
+        Cursors.add(attributes).must_be_instance_of(Cursor)
+      end
+
+      it 'returns a new Cursor after updating' do
+        Cursors.update(attributes).must_be_instance_of(Cursor)
+      end
+
+      context 'when the attributes do not have the :name key' do
+        let(:attributes) { { no_name_key: 'some_value' } }
+
+        it 'raises an exception' do
+          proc { Cursors.update(attributes) }.must_raise(MissingRequired)
+        end
+
+        it 'raises an exception' do
+          proc { Cursors.add(attributes) }.must_raise(MissingRequired)
+        end
+      end
+    end
+
     describe '#hide' do
       it 'sets the state attribute of the Cursor to :hide' do
         cursor = Cursors.hide

data/test/lib/vedeu/repositories/focus_test.rb

@@ -9,52 +9,46 @@ module Vedeu
 
     describe '#add' do
       it 'adds an interface to storage' do
-        Focus.add({ name: 'thallium' }).must_equal(['thallium'])
+        Focus.add('thallium').must_equal(['thallium'])
       end
 
       it 'does not add it again if already exists' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'thallium' })
+        Focus.add('thallium')
+        Focus.add('thallium')
         Focus.registered.must_equal(['thallium'])
       end
 
       it 'adds the interface to storage focussed' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead', focus: true })
+        Focus.add('thallium')
+        Focus.add('lead', true)
         Focus.registered.must_equal(['lead', 'thallium'])
       end
 
       it 'adds the interface to storage unfocussed' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead' })
+        Focus.add('thallium')
+        Focus.add('lead')
         Focus.registered.must_equal(['thallium', 'lead'])
       end
-
-      it 'raises an exception if the attributes does not have a :name key' do
-        attributes = { no_name_key: '' }
-
-        proc { Focus.add(attributes) }.must_raise(MissingRequired)
-      end
     end
 
     describe '#by_name' do
       it 'the named interface is focussed when the method is called' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead' })
-        Focus.add({ name: 'bismuth' })
+        Focus.add('thallium')
+        Focus.add('lead')
+        Focus.add('bismuth')
         Focus.by_name('lead').must_equal('lead')
       end
 
       it 'raises an exception if the interface does not exist' do
-        proc { Focus.by_name('not_found') }.must_raise(InterfaceNotFound)
+        proc { Focus.by_name('not_found') }.must_raise(ModelNotFound)
       end
     end
 
     describe '#current' do
       it 'returns the name of the interface currently in focus' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead' })
-        Focus.add({ name: 'bismuth' })
+        Focus.add('thallium')
+        Focus.add('lead')
+        Focus.add('bismuth')
         Focus.current.must_equal('thallium')
       end
 
@@ -63,6 +57,18 @@ module Vedeu
       end
     end
 
+    describe '#cursor' do
+      before do
+        Interfaces.add({ name: 'thallium' })
+        Focus.add('thallium')
+      end
+
+      it 'returns the escape sequence to render the cursor for the focussed ' \
+         'interface' do
+        Focus.cursor.must_equal("\e[1;1H\e[?25l")
+      end
+    end
+
     describe '#current?' do
       before { Focus.stubs(:current).returns('lead') }
 
@@ -77,9 +83,9 @@ module Vedeu
 
     describe '#next_item' do
       it 'the next interface is focussed when the method is called' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead' })
-        Focus.add({ name: 'bismuth' })
+        Focus.add('thallium')
+        Focus.add('lead')
+        Focus.add('bismuth')
         Focus.next_item.must_equal('lead')
       end
 
@@ -90,9 +96,9 @@ module Vedeu
 
     describe '#prev_item' do
       it 'the previous interface is focussed when the method is called' do
-        Focus.add({ name: 'thallium' })
-        Focus.add({ name: 'lead' })
-        Focus.add({ name: 'bismuth' })
+        Focus.add('thallium')
+        Focus.add('lead')
+        Focus.add('bismuth')
         Focus.prev_item.must_equal('bismuth')
       end
 
@@ -102,9 +108,12 @@ module Vedeu
     end
 
     describe '#refresh' do
-      it 'triggers the event to refresh the interface current in focus' do
-        Focus.add({ name: 'thallium' })
+      before do
+        Focus.add('thallium')
+        Vedeu.stubs(:trigger).returns([])
+      end
 
+      it 'triggers the event to refresh the interface current in focus' do
         Focus.refresh.must_equal([])
       end
     end