vedeu 0.2.8 → 0.2.9

data/lib/vedeu/repositories/focus.rb

@@ -95,22 +95,6 @@ module Vedeu
       Vedeu.trigger("_refresh_#{current}_".to_sym)
     end
 
-    # Returns all registered interfaces by name.
-    #
-    # @return [Array]
-    def registered
-      storage
-    end
-
-    # Returns a boolean indicating whether the named interface is registered.
-    #
-    # @return [Boolean]
-    def registered?(name)
-      return false if storage.empty?
-
-      storage.include?(name)
-    end
-
     private
 
     # Return the name of the interface in focus after triggering the refresh

data/lib/vedeu/support/coercions.rb

@@ -29,6 +29,9 @@ module Vedeu
     # Whenever this module {Vedeu::Coercions} is included in another class or
     # module, make its methods into class methods, so they may be called
     # directly.
+    #
+    # @param receiver [Class] The class in which this module is included.
+    # @return []
     def self.included(receiver)
       receiver.extend(self)
     end

data/lib/vedeu/support/colour_translator.rb

@@ -80,11 +80,17 @@ module Vedeu
       fail NotImplemented, 'Subclasses implement this.'
     end
 
+    # Returns a boolean indicating whether the colour provided is a valid named
+    # colour.
+    #
     # @return [Boolean]
     def valid_name?
       Esc.codes.keys.include?(colour)
     end
 
+    # Returns a boolean indicating whether the colour provided is a terminal
+    # numbered colour.
+    #
     # @return [Boolean]
     def numbered?
       colour.is_a?(Fixnum) && valid_range?
@@ -97,11 +103,16 @@ module Vedeu
       fail NotImplemented, 'Subclasses implement this.'
     end
 
+    # Returns a boolean indicating whether the numbered colour is within the
+    # range of valid terminal numbered colours.
+    #
     # @return [Boolean]
     def valid_range?
       colour >= 0 && colour <= 255
     end
 
+    # Returns a boolean indicated whether the colour is an HTML/CSS colour.
+    #
     # @return [Boolean]
     def rgb?
       colour.is_a?(String) && valid_rgb?
@@ -114,11 +125,20 @@ module Vedeu
       fail NotImplemented, 'Subclasses implement this.'
     end
 
+    # Returns a boolean indicated whether the colour is a valid HTML/CSS colour.
+    #
     # @return [Boolean]
     def valid_rgb?
       !!(colour =~ /^#([A-Fa-f0-9]{6})$/)
     end
 
+    # Returns a collection of converted HTML/CSS octets as their decimal
+    # equivalents.
+    #
+    # @example
+    #   colour = '#aadd55'
+    #   css_to_rgb # => [170, 221, 85]
+    #
     # @return [Array]
     def css_to_rgb
       [
@@ -139,16 +159,25 @@ module Vedeu
       end
     end
 
+    # Takes the red component of {css_to_rgb} and converts to the correct value
+    # for setting the terminal red value.
+    #
     # @return [Fixnum]
     def red
       (css_to_rgb[0] / 51) * 36
     end
 
+    # Takes the green component of {css_to_rgb} and converts to the correct value
+    # for setting the terminal green value.
+    #
     # @return [Fixnum]
     def green
       (css_to_rgb[1] / 51) * 6
     end
 
+    # Takes the blue component of {css_to_rgb} and converts to the correct value
+    # for setting the terminal blue value.
+    #
     # @return [Fixnum]
     def blue
       (css_to_rgb[2] / 51) * 1

data/lib/vedeu/support/log.rb

@@ -3,6 +3,8 @@ require 'time'
 
 module Vedeu
 
+  # Allows the creation of a lock-less log device.
+  #
   # @api private
   class MonoLogger < Logger
 

data/lib/vedeu/support/repository.rb

@@ -42,6 +42,7 @@ module Vedeu
       return [] if storage.empty?
 
       return storage.keys if storage.is_a?(Hash)
+      return storage.to_a if storage.is_a?(Set)
 
       storage
     end

data/test/lib/vedeu/api/api_test.rb

@@ -127,8 +127,13 @@ module Vedeu
     end
 
     describe '.resize' do
-      it 'triggers the :_clear_, and :_refresh_ events' do
-        skip
+      before do
+        Interfaces.reset
+        Terminal.console.stubs(:print)
+      end
+
+      it 'returns a TrueClass' do
+        Vedeu.resize.must_be_instance_of(TrueClass)
       end
     end
 

data/test/lib/vedeu/application_test.rb

@@ -4,24 +4,36 @@ module Vedeu
 
   describe Application do
 
-    describe '.start' do
-      it { skip }
-    end
+    before { Terminal.stubs(:open).returns(['']) }
 
-    describe '.restart' do
-      it { skip }
+    describe '.start' do
+      it 'returns an Array' do
+        Application.start.must_be_instance_of(Array)
+      end
+
+      context 'alias method: .restart' do
+        it 'returns an Array' do
+          Application.restart.must_be_instance_of(Array)
+        end
+      end
     end
 
     describe '.stop' do
-      it { skip }
+      it 'raises an exception' do
+        proc { Application.stop }.must_raise(StopIteration)
+      end
     end
 
     describe '#initialize' do
-      it { skip }
+      it 'returns an Application' do
+        Application.new.must_be_instance_of(Application)
+      end
     end
 
     describe '#start' do
-      it { skip }
+      it 'returns an Array' do
+        Application.new.start.must_be_instance_of(Array)
+      end
     end
 
   end # Application

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

@@ -0,0 +1,182 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Buffer do
+
+    let(:attributes) {
+      {
+        name:     '',
+        back:     back,
+        front:    front,
+        previous: previous,
+      }
+    }
+    let(:back)     { {} }
+    let(:front)    { {} }
+    let(:previous) { {} }
+
+    describe '#initialize' do
+      it 'returns an instance of Buffer' do
+        Buffer.new(attributes).must_be_instance_of(Buffer)
+      end
+    end
+
+    describe '#back' do
+      subject { Buffer.new(attributes).back }
+
+      it { subject.must_be_instance_of(Hash) }
+    end
+
+    describe '#front' do
+      subject { Buffer.new(attributes).front }
+
+      it { subject.must_be_instance_of(Hash) }
+
+      context 'alias method: #current' do
+        subject { Buffer.new(attributes).current }
+
+        it { subject.must_be_instance_of(Hash) }
+      end
+    end
+
+    describe '#name' do
+      subject { Buffer.new(attributes).name }
+
+      it { subject.must_be_instance_of(String) }
+    end
+
+    describe '#previous' do
+      subject { Buffer.new(attributes).previous }
+
+      it { subject.must_be_instance_of(Hash) }
+    end
+
+    describe '#back?' do
+      subject { Buffer.new(attributes).back? }
+
+      context 'when there is content on the back buffer' do
+        let(:back) { { lines: [{ streams: [{ text: 'back' }] }] } }
+
+        it { subject.must_equal(true) }
+      end
+
+      context 'when there is no content on the back buffer' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'when there is no content on the back buffer' do
+        let(:back) { { lines: [] } }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#front?' do
+      subject { Buffer.new(attributes).front? }
+
+      context 'when there is content on the front buffer' do
+        let(:front) { { lines: [{ streams: [{ text: 'front' }] }] } }
+
+        it { subject.must_equal(true) }
+      end
+
+      context 'when there is no content on the front buffer' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'when there is no content on the front buffer' do
+        let(:front) { { lines: [] } }
+
+        it { subject.must_equal(false) }
+      end
+
+      context 'alias method: #current?' do
+        subject { Buffer.new(attributes).current? }
+
+        context 'when there is no content on the front buffer' do
+          it { subject.must_equal(false) }
+        end
+      end
+    end
+
+    describe '#previous?' do
+      subject { Buffer.new(attributes).previous? }
+
+      context 'when there is content on the previous buffer' do
+        let(:previous) { { lines: [{ streams: [{ text: 'previous' }] }] } }
+
+        it { subject.must_equal(true) }
+      end
+
+      context 'when there is no content on the previous buffer' do
+        it { subject.must_equal(false) }
+      end
+
+      context 'when there is no content on the previous buffer' do
+        let(:previous) { { lines: [] } }
+
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#add' do
+      let(:attributes) {
+        {
+          back: { lines: [{ streams: [{ text: 'old_back' }] }] }
+        }
+      }
+      let(:buffer)  { Buffer.new(attributes) }
+      let(:content) { { lines: [{ streams: [{ text: 'new_back' }] }] } }
+
+      subject { buffer.add(content) }
+
+      it { subject.must_equal(true) }
+
+      it 'replaces the back buffer with the content' do
+        buffer.back.must_equal({ lines: [{ streams: [{ text: 'old_back' }] }] })
+
+        subject
+
+        buffer.back.must_equal({ lines: [{ streams: [{ text: 'new_back' }] }] })
+      end
+    end
+
+    describe '#swap' do
+      let(:buffer) { Buffer.new(attributes) }
+
+      subject { buffer.swap }
+
+      context 'when there is new content on the back buffer' do
+        let(:back)     { { lines: [{ streams: [{ text: 'back' }] }] } }
+        let(:front)    { { lines: [{ streams: [{ text: 'front' }] }] } }
+        let(:previous) { { lines: [{ streams: [{ text: 'previous' }] }] } }
+
+        context 'when the buffer was updated successfully' do
+          it { subject.must_equal(true) }
+        end
+
+        it 'replaces the previous buffer with the front buffer' do
+          subject
+          buffer.previous.must_equal(front)
+        end
+
+        it 'replaces the front buffer with the back buffer' do
+          subject
+          buffer.front.must_equal(back)
+        end
+
+        it 'replaces the back buffer with an empty buffer' do
+          subject
+          buffer.back.must_equal({})
+        end
+      end
+
+      context 'when there is no new content on the back buffer' do
+        it { subject.must_equal(false) }
+      end
+    end
+
+  end # Buffer
+
+end # Vedeu

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

@@ -4,7 +4,10 @@ module Vedeu
 
   describe Clear do
 
-    before { Interfaces.reset }
+    before do
+      Interfaces.reset
+      Terminal.console.stubs(:print)
+    end
 
     describe '#initialize' do
       it 'returns an instance of itself' do
@@ -22,10 +25,10 @@ module Vedeu
             height: 2
           }
         })
-        Clear.call(interface).must_equal(
+        Clear.call(interface).must_equal([
           "\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
@@ -40,11 +43,11 @@ module Vedeu
             background: '#ffff00'
           }
         })
-        Clear.call(interface).must_equal(
+        Clear.call(interface).must_equal([
           "\e[38;2;0;255;0m\e[48;2;255;255;0m" \
           "\e[1;1H     \e[1;1H" \
           "\e[2;1H     \e[2;1H"
-        )
+        ])
       end
     end
 

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

@@ -5,73 +5,121 @@ module Vedeu
   describe Compositor do
 
     before do
+      Buffers.reset
       Interfaces.reset
       Terminal.console.stubs(:print)
     end
 
     describe '.render' do
-      it 'raises an exception if the buffer/interface cannot be found' do
-        proc { Compositor.render('') }.must_raise(BufferNotFound)
+      before do
+        Vedeu.interface('indium') do
+          width  10
+          height 1
+        end
       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
+      subject { Compositor.render('indium') }
+
+      context 'when the buffer does not exist' do
+        it 'raises an exception' do
+          proc { Compositor.render('') }.must_raise(BufferNotFound)
+        end
+      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 do
+            Buffers.add(back)
           end
 
-          Vedeu.focus('xenon')
+          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)
 
-          Compositor.render('xenon').must_equal([
-            "\e[1;1H     \e[1;1H" \
-            "\e[2;1H     \e[2;1H" \
-            "\e[3;1H     \e[3;1H",
+            subject
 
-            "\e[1;1H\e[?25l"
-          ])
+            Buffers.find('indium').back.must_equal({})
+            Buffers.find('indium').front.must_equal(back)
+          end
         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
+        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)
+            Buffers.find('indium').swap
+            Buffers.find('indium').swap
+          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
 
-          Vedeu.focus('neon')
+        context 'when there is no new, current or previous content' do
+          let(:clear) { { name: 'indium', lines: [] } }
 
-          class MyCompositorView < Vedeu::View
-            def render
-              view 'neon' do
-                line 'argon'
-                line 'boron'
-                line 'radon'
-              end
-            end
+          before do
+            Buffers.add(clear)
           end
 
-          MyCompositorView.render
+          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
+      end
 
-          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",
+      context 'when the interface cannot be found' do
+        before do
+          Interfaces.reset
+          Buffers.add({ name: 'indium' })
+        end
 
-            "\e[1;1H\e[?25l"
-          ])
+        it 'raises an exception' do
+          proc { Compositor.render('indium') }.must_raise(InterfaceNotFound)
         end
       end
     end
 
+    describe '#initialize' do
+      it 'returns an instance of Compositor' do
+        Compositor.new('indium').must_be_instance_of(Compositor)
+      end
+    end
+
   end # Compositor
 
 end # Vedeu