vedeu 0.6.42 → 0.6.43

data/lib/vedeu/models/views/view.rb

@@ -28,6 +28,11 @@ module Vedeu
       # @return [Fixnum|Float]
       attr_accessor :client
 
+      # @!attribute [rw] cursor_visible
+      # @return [Boolean]
+      attr_accessor :cursor_visible
+      alias_method :cursor_visible?, :cursor_visible
+
       # @!attribute [rw] name
       # @return [String]
       attr_accessor :name
@@ -49,6 +54,7 @@ module Vedeu
       # @param attributes [Hash]
       # @option attributes client [Vedeu::Client]
       # @option attributes colour [Vedeu::Colours::Colour]
+      # @option attributes cursor_visible [Boolean]
       # @option attributes value [Vedeu::Views::Lines]
       # @option attributes name [String|Symbol]
       # @option attributes parent [Vedeu::Views::Composition]
@@ -118,14 +124,14 @@ module Vedeu
       # @return [Hash]
       def defaults
         {
-          client: nil,
-          colour: Vedeu::Colours::Colour.coerce(background: :default,
-                                                foreground: :default),
-          name:   '',
-          parent: nil,
-          style:  :normal,
-          value:  [],
-          zindex: 0,
+          client:         nil,
+          colour:         Vedeu::Colours::Colour.default,
+          cursor_visible: true,
+          name:           '',
+          parent:         nil,
+          style:          :normal,
+          value:          [],
+          zindex:         0,
         }
       end
 

data/lib/vedeu/null/generic.rb

@@ -28,6 +28,7 @@ module Vedeu
       def falsy
         false
       end
+      alias_method :cursor_visible?, :falsy
       alias_method :enabled?, :falsy
       alias_method :maximise, :falsy
       alias_method :maximised?, :falsy

data/lib/vedeu/output/renderers/all.rb

@@ -18,6 +18,9 @@ module Vedeu
     # @return [Array<void>]
     def clear
       threads = storage.map do |renderer|
+        Vedeu.log(type:    :output,
+                  message: "Clearing via #{renderer.class.name}")
+
         Thread.new(renderer) do
           mutex.synchronize do
             toggle_cursor { renderer.clear }
@@ -49,6 +52,9 @@ module Vedeu
     # @return [Array<void>]
     def render(output)
       threads = storage.map do |renderer|
+        Vedeu.log(type:    :output,
+                  message: "Rendering via #{renderer.class.name}")
+
         Thread.new(renderer) do
           mutex.synchronize do
             toggle_cursor { renderer.render(output) }
@@ -127,10 +133,7 @@ module Vedeu
 end # Vedeu
 
 require 'vedeu/output/renderers/options'
-require 'vedeu/output/renderers/escape_sequence'
 require 'vedeu/output/renderers/file'
 require 'vedeu/output/renderers/html'
 require 'vedeu/output/renderers/json'
-require 'vedeu/output/renderers/null'
 require 'vedeu/output/renderers/terminal'
-require 'vedeu/output/renderers/text'

data/lib/vedeu/version.rb

@@ -1,6 +1,6 @@
 module Vedeu
 
   # The current version of Vedeu.
-  VERSION = '0.6.42'.freeze
+  VERSION = '0.6.43'.freeze
 
 end

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

@@ -71,6 +71,77 @@ module Vedeu
         end
       end
 
+      describe '#cursor_visible?' do
+        let(:buffer) {
+          Vedeu::Views::View.new(value: [Vedeu::Views::Line.new],
+                                 cursor_visible: cursor_visible)
+        }
+        let(:cursor_visible) { false }
+
+        subject { instance.cursor_visible? }
+
+        context 'when there is a front buffer' do
+          let(:front) { buffer }
+
+          context 'when the cursor is visible' do
+            let(:cursor_visible) { true }
+
+            it { subject.must_equal(true) }
+          end
+
+          context 'when the cursor is not visible' do
+            it { subject.must_equal(false) }
+          end
+        end
+
+        context 'when there is a previous buffer' do
+          let(:front)    {}
+          let(:previous) { buffer }
+
+          context 'when the cursor is visible' do
+            let(:cursor_visible) { true }
+
+            it { subject.must_equal(true) }
+          end
+
+          context 'when the cursor is not visible' do
+            it { subject.must_equal(false) }
+          end
+        end
+
+        context 'when neither a front or previous buffer exists (yet)' do
+          let(:front)     {}
+          let(:previous)  {}
+
+          context 'when an interface exists' do
+            let(:interface) {
+              Vedeu::Interfaces::Interface.new(name: _name, cursor_visible: cursor_visible)
+            }
+            let(:cursor_visible) { false }
+
+            before do
+              Vedeu.interfaces.stubs(:by_name).with(_name).returns(interface)
+            end
+
+            context 'when the interface cursor_visible is false' do
+              it { subject.must_equal(false) }
+            end
+
+            context 'when the interface cursor_visible is true' do
+              let(:cursor_visible) { true }
+
+              it { subject.must_equal(true) }
+            end
+          end
+
+          context 'when an interface does not exist' do
+            it 'uses the Interface::Null cursor_visible (always false)' do
+              subject.must_equal(false)
+            end
+          end
+        end
+      end
+
       describe '#front?' do
         subject { instance.front? }
 

data/test/lib/vedeu/colours/colour_test.rb

@@ -167,6 +167,12 @@ module Vedeu
         end
       end
 
+      describe '.default' do
+        subject { described.default }
+
+        it { subject.must_be_instance_of(Vedeu::Colours::Colour) }
+      end
+
       describe '#background=' do
         let(:_value) { '#000000' }
 

data/test/lib/vedeu/cursors/dsl_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Cursors
+
+    describe DSL do
+
+      let(:described) { Vedeu::Cursors::DSL }
+
+      # describe '#cursor' do
+      #   let(:_value) {}
+
+      #   before { Vedeu.cursors.reset }
+
+      #   subject { instance.cursor(_value) }
+
+      #   it {
+      #     subject
+      #     Vedeu.cursors.find('actinium').visible?.must_equal(false)
+      #   }
+
+      #   context 'when the value is false' do
+      #     let(:_value) { false }
+
+      #     it {
+      #       subject
+      #       Vedeu.cursors.find('actinium').visible?.must_equal(false)
+      #     }
+      #   end
+
+      #   context 'when the value is nil' do
+      #     let(:_value) {}
+
+      #     it {
+      #       subject
+      #       Vedeu.cursors.find('actinium').visible?.must_equal(false)
+      #     }
+      #   end
+
+      #   context 'when the value is :show' do
+      #     let(:_value) { :show }
+
+      #     it {
+      #       subject
+      #       Vedeu.cursors.find('actinium').visible?.must_equal(true)
+      #     }
+      #   end
+
+      #   context 'when the value is true' do
+      #     let(:_value) { true }
+
+      #     it {
+      #       subject
+      #       Vedeu.cursors.find('actinium').visible?.must_equal(true)
+      #     }
+      #   end
+
+      #   context 'when the value is :yes' do
+      #     let(:_value) { :yes }
+
+      #     it {
+      #       subject
+      #       Vedeu.cursors.find('actinium').visible?.must_equal(true)
+      #     }
+      #   end
+      # end
+
+      # describe '#cursor!' do
+      #   subject { instance.cursor! }
+
+      #   it {
+      #     subject
+      #     Vedeu.cursors.find('actinium').visible?.must_equal(true)
+      #   }
+      # end
+
+      # describe '#no_cursor!' do
+      #   subject { instance.no_cursor! }
+
+      #   it {
+      #     subject
+      #     Vedeu.cursors.find('actinium').visible?.must_equal(false)
+      #   }
+      # end
+
+    end # DSL
+
+  end # Cursors
+
+end # Vedeu

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

@@ -14,8 +14,15 @@ module Vedeu
       let(:instance)  { described.new(_name) }
       let(:_name)     { 'refresh_cursor' }
       let(:expected)  {}
+      let(:cursor)    {
+        Vedeu::Cursors::Cursor.store(name:    _name,
+                                     ox:      ox,
+                                     oy:      oy,
+                                     visible: visible)
+      }
       let(:ox)        { 0 }
       let(:oy)        { 0 }
+      let(:visible)   { false }
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
@@ -31,38 +38,41 @@ module Vedeu
             y  1
             yn 3
           end
-          Vedeu::Cursors::Cursor.store(name: 'refresh_cursor',
-                                       ox:   ox,
-                                       oy:   oy)
-
+          Vedeu.cursors.stubs(:by_name).with(_name).returns(cursor)
           Vedeu::Terminal.stubs(:output).returns(expected)
-
-          Vedeu.stubs(:trigger)
         end
 
         subject { described.by_name(_name) }
 
-        it 'renders the cursor in the terminal' do
-          Vedeu::Terminal.expects(:output).with("\e[1;1H\e[?25l")
-          subject
-        end
-
-        context 'when the cursors offset position is outside the viewable area' do
-          let(:ox) { 3 }
-          let(:oy) { 3 }
+        context 'when the cursor is visible' do
+          let(:visible) { true }
 
-          it 'refreshes the view' do
-            Vedeu.expects(:trigger).with(:_refresh_view_content_, _name)
+          it 'renders the cursor in the terminal' do
+            cursor.expects(:render)
             subject
           end
-        end
 
-        context 'when the cursors offset position is inside the viewable area' do
-          it 'does not refresh the view' do
-            Vedeu.expects(:trigger).with(:_refresh_view_content_, _name).never
-            subject
+          context 'when the cursors offset position is outside the viewable area' do
+            let(:ox) { 3 }
+            let(:oy) { 3 }
+
+            it 'refreshes the view' do
+              Vedeu.expects(:trigger).with(:_refresh_view_content_, _name)
+              subject
+            end
+          end
+
+          context 'when the cursors offset position is inside the viewable area' do
+            it 'does not refresh the view' do
+              Vedeu.expects(:trigger).with(:_refresh_view_content_, _name).never
+              subject
+            end
           end
         end
+
+        context 'when the cursor is not visible' do
+          it { subject.must_equal(nil) }
+        end
       end
 
       describe '#by_name' do

data/test/lib/vedeu/interfaces/dsl_test.rb

@@ -42,73 +42,6 @@ module Vedeu
         end
       end
 
-      describe '#cursor' do
-        let(:_value) {}
-
-        before { Vedeu.cursors.reset }
-
-        subject { instance.cursor(_value) }
-
-        it {
-          subject
-          Vedeu.cursors.find('actinium').visible?.must_equal(false)
-        }
-
-        context 'when the value is false' do
-          let(:_value) { false }
-
-          it {
-            subject
-            Vedeu.cursors.find('actinium').visible?.must_equal(false)
-          }
-        end
-
-        context 'when the value is nil' do
-          let(:_value) {}
-
-          it {
-            subject
-            Vedeu.cursors.find('actinium').visible?.must_equal(false)
-          }
-        end
-
-        context 'when the value is :show' do
-          let(:_value) { :show }
-
-          it {
-            subject
-            Vedeu.cursors.find('actinium').visible?.must_equal(true)
-          }
-        end
-
-        context 'when the value is true' do
-          let(:_value) { true }
-
-          it {
-            subject
-            Vedeu.cursors.find('actinium').visible?.must_equal(true)
-          }
-        end
-
-        context 'when the value is :yes' do
-          let(:_value) { :yes }
-
-          it {
-            subject
-            Vedeu.cursors.find('actinium').visible?.must_equal(true)
-          }
-        end
-      end
-
-      describe '#cursor!' do
-        subject { instance.cursor! }
-
-        it {
-          subject
-          Vedeu.cursors.find('actinium').visible?.must_equal(true)
-        }
-      end
-
       describe '#delay' do
         subject { instance.delay(0.25) }
 
@@ -219,15 +152,6 @@ module Vedeu
         }
       end
 
-      describe '#no_cursor!' do
-        subject { instance.no_cursor! }
-
-        it {
-          subject
-          Vedeu.cursors.find('actinium').visible?.must_equal(false)
-        }
-      end
-
       describe '#show!' do
         subject {
           Vedeu.interface 'xenon' do

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

@@ -10,35 +10,38 @@ module Vedeu
       let(:instance)   { described.new(attributes) }
       let(:attributes) {
         {
-          client:   client,
-          colour:   colour,
-          delay:    delay,
-          editable: editable,
-          group:    group,
-          name:     _name,
-          parent:   parent,
-          style:    style,
-          visible:  visible,
-          zindex:   zindex,
+          client:         client,
+          colour:         colour,
+          cursor_visible: cursor_visible,
+          delay:          delay,
+          editable:       editable,
+          group:          group,
+          name:           _name,
+          parent:         parent,
+          style:          style,
+          visible:        visible,
+          zindex:         zindex,
         }
       }
-      let(:client)     {}
-      let(:colour)     {}
-      let(:delay)      { 0.0 }
-      let(:editable)   { false }
-      let(:group)      { '' }
-      let(:_name)      { 'hydrogen' }
-      let(:parent)     {}
-      let(:repository) { Vedeu.interfaces }
-      let(:style)      {}
-      let(:visible)    { true }
-      let(:zindex)     { 1 }
+      let(:client)         {}
+      let(:colour)         {}
+      let(:cursor_visible) { true }
+      let(:delay)          { 0.0 }
+      let(:editable)       { false }
+      let(:group)          { '' }
+      let(:_name)          { 'hydrogen' }
+      let(:parent)         {}
+      let(:repository)     { Vedeu.interfaces }
+      let(:style)          {}
+      let(:visible)        { true }
+      let(:zindex)         { 1 }
 
       describe '#initialize' do
         subject { instance }
 
         it { subject.must_be_instance_of(described) }
         it { subject.instance_variable_get('@client').must_equal(client) }
+        it { subject.instance_variable_get('@cursor_visible').must_equal(cursor_visible) }
         it { subject.instance_variable_get('@delay').must_equal(delay) }
         it { subject.instance_variable_get('@editable').must_equal(editable) }
         it { subject.instance_variable_get('@group').must_equal(group) }
@@ -55,6 +58,8 @@ module Vedeu
         it {
           instance.must_respond_to(:client)
           instance.must_respond_to(:client=)
+          instance.must_respond_to(:cursor_visible)
+          instance.must_respond_to(:cursor_visible=)
           instance.must_respond_to(:delay)
           instance.must_respond_to(:delay=)
           instance.must_respond_to(:editable)