vedeu 0.1.18 → 0.1.19

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

@@ -2,6 +2,31 @@ require 'test_helper'
 
 module Vedeu
   describe Geometry do
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        attributes = {}
+        Geometry.new(attributes).must_be_instance_of(Geometry)
+      end
+    end
+
+    describe '#y' do
+      it 'returns the value of y when it is a proc' do
+        IO.console.stub(:winsize, [25, 80]) do
+          geometry = Geometry.new({ y: proc { 17 } })
+          geometry.y.must_equal(17)
+        end
+      end
+    end
+
+    describe '#x' do
+      it 'returns the value of x when it is a proc' do
+        IO.console.stub(:winsize, [25, 80]) do
+          geometry = Geometry.new({ x: proc { 58 } })
+          geometry.x.must_equal(58)
+        end
+      end
+    end
+
     describe '#viewport_width' do
       it 'returns the viewport width when the interface fits the terminal' do
         IO.console.stub(:winsize, [25, 80]) do
@@ -17,6 +42,13 @@ module Vedeu
           geometry.viewport_width.must_equal(55)
         end
       end
+
+      it 'returns an unusable viewport width when the terminal is tiny' do
+        IO.console.stub(:winsize, [25, -10]) do
+          geometry = Geometry.new({ width: 60, height: 1, x: 5, y: 1 })
+          geometry.viewport_width.must_equal(1)
+        end
+      end
     end
 
     describe '#viewport_height' do
@@ -34,6 +66,13 @@ module Vedeu
           geometry.viewport_height.must_equal(10)
         end
       end
+
+      it 'returns an unusable viewport height when the terminal is tiny' do
+        IO.console.stub(:winsize, [-10, 80]) do
+          geometry = Geometry.new({ width: 60, height: 20, x: 1, y: 5 })
+          geometry.viewport_height.must_equal(1)
+        end
+      end
     end
 
     describe '#origin' do

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

@@ -20,6 +20,15 @@ module Vedeu
       })
     }
 
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        attributes = {}
+
+        Interface.new(attributes).must_be_instance_of(Interface)
+      end
+    end
+
+
     describe '#attributes' do
       it 'returns the value' do
         interface.attributes.must_equal(
@@ -39,7 +48,8 @@ module Vedeu
               height: 15
             },
             cursor: true,
-            delay: 0.0
+            delay: 0.0,
+            parent: nil
           }
         )
       end

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

@@ -10,10 +10,17 @@ module Vedeu
           background: '#000000'
         },
         streams: [],
-        style:   'normal'
+        style:   'normal',
+        parent:  nil,
       }
     }
 
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        Line.new(attributes).must_be_instance_of(Line)
+      end
+    end
+
     describe '#attributes' do
       it 'returns the attributes' do
         line.attributes.must_equal(attributes)

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

@@ -18,6 +18,13 @@ module Vedeu
     let(:align) { :left }
     let(:width) { 9 }
 
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        attributes = {}
+        Stream.new(attributes).must_be_instance_of(Stream)
+      end
+    end
+
     describe '#text' do
       it 'has a text attribute' do
         stream.text.must_equal('Some text')
@@ -37,6 +44,34 @@ module Vedeu
     end
 
     describe '#to_s' do
+      it 'reverts to the colours of the line after rendering itself' do
+        line   = Line.new({
+          colour: {
+            foreground: '#00ff00',
+            background: '#000000'
+          },
+          style: 'normal'
+        })
+        stream = Stream.new({
+          colour: {
+            foreground: '#ff0000',
+            background: '#000000'
+          },
+          text:  'Some text',
+          style: 'underline',
+          width: nil,
+          align: :left,
+          parent: line.view_attributes,
+        })
+        stream.to_s.must_equal(
+          "\e[38;2;255;0;0m\e[48;2;0;0;0m" \
+          "\e[4m" \
+          "Some text" \
+          "\e[24m\e[22m\e[27m" \
+          "\e[38;2;0;255;0m\e[48;2;0;0;0m"
+        )
+      end
+
       describe 'when a width is set and align is default' do
         let(:width) { 20 }
 

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

@@ -2,6 +2,14 @@ require 'test_helper'
 
 module Vedeu
   describe Style do
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        values = ''
+
+        Style.new(values).must_be_instance_of(Style)
+      end
+    end
+
     describe '#to_s' do
       describe 'for a single style' do
         let(:values) { 'normal' }

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

@@ -2,7 +2,7 @@ require 'test_helper'
 
 module Vedeu
   describe Clear do
-    before { Buffers.reset }
+    before { Interfaces.reset }
 
     describe '#initialize' do
       it 'returns an instance of itself' do

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

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+module Vedeu
+  describe Compositor do
+    before { Terminal.console.stubs(:print) }
+
+    describe '.render' do
+      it 'raises an exception if the buffer/interface cannot be found' do
+        proc { Compositor.render('') }.must_raise(BufferNotFound)
+      end
+
+      context 'when the buffer is nil' do
+        it 'clears the defined area for the interface' do
+          Vedeu.interface('xenon') do
+            x      1
+            y      1
+            width  5
+            height 3
+          end
+
+          Compositor.render('xenon').must_equal([
+            "\e[1;1H     \e[1;1H" \
+            "\e[2;1H     \e[2;1H" \
+            "\e[3;1H     \e[3;1H" \
+            "\e[?25h"
+          ])
+        end
+      end
+
+      context 'when the buffer is not nil' do
+        it 'renders the content in the defined area for the interface' do
+          Vedeu.interface('neon') do
+            x      1
+            y      1
+            width  5
+            height 3
+          end
+
+          class MyCompositorView < Vedeu::View
+            def render
+              view 'neon' do
+                line 'argon'
+                line 'boron'
+                line 'radon'
+              end
+            end
+          end
+
+          MyCompositorView.render
+
+          Compositor.render('neon').must_equal([
+            "\e[1;1H     \e[1;1H" \
+            "\e[2;1H     \e[2;1H" \
+            "\e[3;1H     \e[3;1H" \
+            "\e[1;1Hargon" \
+            "\e[2;1Hboron" \
+            "\e[3;1Hradon" \
+            "\e[?25h"
+          ])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Vedeu
+  describe Refresh do
+    describe '.add_interface' do
+      it 'returns false when provided with no attributes' do
+        Refresh.add_interface({}).must_equal(false)
+      end
+    end
+
+    describe '.add_group' do
+      it 'returns false when provided with no attributes' do
+        Refresh.add_group({}).must_equal(false)
+      end
+    end
+
+    describe '.all' do
+      it 'returns an empty collection when there are no registered ' \
+         'interfaces' do
+        Interfaces.reset
+
+        Refresh.all.must_equal([])
+      end
+    end
+
+    describe '.by_focus' do
+      it 'raises an exception when there are no registered interfaces' do
+        Focus.reset
+
+        proc { Refresh.by_focus }.must_raise(NoInterfacesDefined)
+      end
+    end
+
+    describe '.by_group' do
+      it 'raises an exception when the group cannot be found' do
+        Groups.reset
+
+        proc { Refresh.by_group('') }.must_raise(GroupNotFound)
+      end
+    end
+
+    describe '.by_name' do
+      it 'raises an exception when the buffer cannot be found' do
+        proc { Refresh.by_name('') }.must_raise(BufferNotFound)
+      end
+    end
+  end
+end

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

@@ -95,6 +95,42 @@ module Vedeu
           "\e[3;1Hthis is the third, it is even lo\e[?25l"
         )
       end
+
+      it 'returns the content for the interface, starting at the optional ' \
+         'top' do
+        interface = Interface.new({
+          name:     '.call',
+          geometry: {
+            width:  32,
+            height: 4,
+          },
+          lines:    [
+            {
+              streams: [{ text: 'this is the first' }]
+            }, {
+              streams: { text: 'this is the second and it is long' }
+            }, {
+              streams: [
+                { text: 'this is the third, ' },
+                { text: 'it is even longer '  },
+                { text: 'and still truncated' }
+              ]
+            }, {
+              streams: [{ text: 'this is exciting!' }]
+            }
+          ]
+        })
+        Render.call(interface, { top: 1 }).must_equal(
+          "\e[1;1H                                \e[1;1H" \
+          "\e[2;1H                                \e[2;1H" \
+          "\e[3;1H                                \e[3;1H" \
+          "\e[4;1H                                \e[4;1H" \
+          "\e[1;1Hthis is the second and it is lon" \
+          "\e[2;1Hthis is the third, it is even lo" \
+          "\e[3;1Hthis is exciting!\e[?25h"
+        )
+      end
+
     end
   end
 end

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

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Vedeu
+  describe Buffers do
+
+    describe '.create' do
+    end
+
+    describe '.add' do
+    end
+
+    describe '.find' do
+      context 'when the buffer does not exist by this name' do
+      end
+
+      context 'when the buffer can be found by name' do
+      end
+    end
+
+    describe '.latest' do
+      context 'when the buffer does not exist by this name' do
+      end
+
+      context 'when the buffer can be found by name' do
+      end
+    end
+
+    describe '.content' do
+      context 'when the buffer does not exist by this name' do
+      end
+
+      context 'when the buffer can be found by name' do
+      end
+    end
+
+    describe '.swap_buffers' do
+      context 'when the buffer does not exist by this name' do
+      end
+
+      context 'when the buffer can be found by name' do
+      end
+    end
+
+    describe '.reset' do
+    end
+
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Vedeu
+  describe Focus do
+    before { Focus.reset }
+    after  { Focus.reset }
+
+    describe '#add' do
+      it 'adds an interface to storage focussed' do
+        Focus.add({ name: 'thallium' }).must_equal(['thallium'])
+      end
+
+      it 'does not add it again if already exists' do
+        Focus.add({ name: 'thallium' })
+        Focus.add({ name: 'thallium' })
+        Focus.registered.must_equal(['thallium'])
+      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.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)
+      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.current.must_equal('thallium')
+      end
+
+      it 'raises an exception if there are no interfaces defined' do
+        proc { Focus.current }.must_raise(NoInterfacesDefined)
+      end
+    end
+
+    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.next_item.must_equal('lead')
+      end
+    end
+
+    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.prev_item.must_equal('bismuth')
+      end
+    end
+
+    describe '#registered' do
+      it 'returns all the names of the interfaces which can be focussed' do
+        Focus.add({ name: 'thallium' })
+        Focus.add({ name: 'lead' })
+        Focus.add({ name: 'bismuth' })
+
+        Focus.registered.must_equal(['thallium', 'lead', 'bismuth'])
+      end
+    end
+  end
+end