vedeu 0.4.46 → 0.4.47

data/lib/vedeu/support/log.rb

@@ -165,6 +165,7 @@ module Vedeu
           info:   [:white,         :default],
           input:  [:light_yellow,  :yellow],
           output: [:light_green,   :green],
+          reset:  [:light_cyan,    :cyan],
           store:  [:light_cyan,    :cyan],
           test:   [:light_white,   :white],
           timer:  [:light_yellow,  :yellow],

data/lib/vedeu/support/terminal.rb

@@ -67,16 +67,7 @@ module Vedeu
     # @param streams [String|Array]
     # @return [Array]
     def output(*streams)
-      streams.each do |stream|
-        # Write the stream to the log file.
-        # Vedeu.log(Esc.escape(stream))
-
-        console.print(stream)
-
-        # Vedeu::Console.write(stream)
-      end
-
-      streams
+      streams.each { |stream| console.print(stream) }
     end
     alias_method :write, :output
 

data/lib/vedeu/support/visibility.rb

@@ -100,7 +100,6 @@ module Vedeu
       end
     end
 
-
     # @return [void]
     def toggle
       if model.visible?

data/lib/vedeu/version.rb

@@ -1,6 +1,6 @@
 module Vedeu
 
   # The current version of Vedeu.
-  VERSION = '0.4.46'
+  VERSION = '0.4.47'
 
 end

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

@@ -90,6 +90,8 @@ module Vedeu
         }
       }
 
+      before { Vedeu.stubs(:trigger) }
+
       subject { instance.maximise }
 
       it { subject.must_be_instance_of(described) }
@@ -107,6 +109,8 @@ module Vedeu
         }
       }
 
+      before { Vedeu.stubs(:trigger) }
+
       subject { instance.unmaximise }
 
       it { subject.must_be_instance_of(described) }

data/test/lib/vedeu/geometry/position_test.rb

@@ -29,11 +29,27 @@ module Vedeu
     end
 
     describe '#<=>' do
-      let(:other) {}
-
       subject { instance.<=>(other) }
 
-      # it { skip }
+      context 'when y is the same as other.y' do
+        context 'when x is the same as other.x' do
+          let(:other) { described.new(12, 19) }
+
+          it { subject.must_equal(0) }
+        end
+
+        context 'when x is different to other.x' do
+          let(:other) { described.new(12, 21) }
+
+          it { subject.must_equal(-1) }
+        end
+      end
+
+      context 'when y is different to other.y' do
+        let(:other) { described.new(14, 19) }
+
+        it { subject.must_equal(-1) }
+      end
     end
 
     describe '.coerce' do
@@ -89,9 +105,10 @@ module Vedeu
     end
 
     describe '#to_position' do
-      subject { Position.new }
+      subject { instance.to_position }
 
       it { subject.must_be_instance_of(Vedeu::Position) }
+      it { subject.must_equal(instance) }
     end
 
     describe '#to_s' do
@@ -102,7 +119,7 @@ module Vedeu
       end
 
       it 'returns an escape sequence when coordinates are provided' do
-        Position.new(12, 19).to_s.must_equal("\e[12;19H")
+        Position[12, 19].to_s.must_equal("\e[12;19H")
       end
 
       it 'returns an escape sequence if a coordinate is missing' do
@@ -110,15 +127,15 @@ module Vedeu
       end
 
       it 'returns an escape sequence if the x coordinate is negative' do
-        Position.new(12, -5).to_s.must_equal("\e[12;1H")
+        Position[12, -5].to_s.must_equal("\e[12;1H")
       end
 
       it 'returns an escape sequence if the y coordinate is negative' do
-        Position.new(-12, 5).to_s.must_equal("\e[1;5H")
+        Position[-12, 5].to_s.must_equal("\e[1;5H")
       end
 
       it 'resets to starting position when a block is given' do
-        Position.new(4, 9).to_s { 'test' }.must_equal("\e[4;9Htest\e[4;9H")
+        Position[4, 9].to_s { 'test' }.must_equal("\e[4;9Htest\e[4;9H")
       end
     end
 

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

@@ -74,7 +74,7 @@ module Vedeu
     describe '#inspect' do
       let(:colour)   { Vedeu::Colour.new(foreground: '#00ff00',
                                          background: '#005500') }
-      let(:position) { Vedeu::Position.new(17, 2) }
+      let(:position) { Vedeu::Position[17, 2] }
       let(:style)    { Vedeu::Style.new('underline') }
 
 
@@ -136,7 +136,7 @@ module Vedeu
       it { subject.must_be_instance_of(String) }
 
       context 'when a position is specified' do
-        let(:position) { Vedeu::Position.new(17, 2) }
+        let(:position) { Vedeu::Position[17, 2] }
 
         it { subject.must_equal("\e[17;2Ha\e[17;2H") }
       end
@@ -218,7 +218,7 @@ module Vedeu
     end
 
     describe '#x' do
-      let(:position) { Vedeu::Position.new(17, 2) }
+      let(:position) { Vedeu::Position[17, 2] }
 
       subject { instance.x }
 
@@ -234,7 +234,7 @@ module Vedeu
     end
 
     describe '#y' do
-      let(:position) { Vedeu::Position.new(17, 2) }
+      let(:position) { Vedeu::Position[17, 2] }
 
       subject { instance.y }
 

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

@@ -107,8 +107,8 @@ module Vedeu
       let(:view)   { mock('Vedeu::Viewport') }
 
       before do
-        Vedeu::Clear.stubs(:new).returns(clear)
-        clear.stubs(:render).returns(:clear)
+        Vedeu::Clear::NamedInterface.stubs(:render).returns(:clear)
+
         Vedeu.borders.stubs(:by_name).returns(border)
         border.stubs(:render).returns(:border)
         Vedeu::Viewport.stubs(:new).returns(view)
@@ -120,6 +120,11 @@ module Vedeu
       it { subject.must_be_instance_of(Array) }
 
       context 'when the interface is visible' do
+        it {
+          Vedeu::Clear::NamedInterface.expects(:render).with(_name)
+          subject
+        }
+
         it { subject.must_equal([:clear, :border, :view]) }
       end
 

data/test/lib/vedeu/output/clear/named_group_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Clear
+
+    describe NamedGroup do
+
+      let(:described) { Vedeu::Clear::NamedGroup }
+      let(:instance)  { described.new(_name) }
+      let(:_name)     { 'Vedeu::Clear::NamedGroup' }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+      end
+
+      describe '.render' do
+        it { described.must_respond_to(:by_group) }
+        it { described.must_respond_to(:clear_by_group) }
+        it { described.must_respond_to(:render) }
+      end
+
+      describe '#render' do
+        let(:group) { Vedeu::Group.new(members: [_name]) }
+
+        before { Vedeu.groups.stubs(:by_name).returns(group) }
+
+        subject { instance.render }
+
+        it {
+          Vedeu::Clear::NamedInterface.expects(:render).with(_name)
+          subject
+        }
+      end
+
+    end # NamedGroup
+
+  end # Clear
+
+end # Vedeu

data/test/lib/vedeu/output/clear/named_interface_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Clear
+
+    describe NamedInterface do
+
+      let(:described) { Vedeu::Clear::NamedInterface }
+      let(:instance)  { described.new(_name) }
+      let(:_name)     { 'Vedeu::Clear::NamedInterface' }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(_name) }
+      end
+
+      describe '.render' do
+        it { described.must_respond_to(:by_name) }
+        it { described.must_respond_to(:clear_by_name) }
+        it { described.must_respond_to(:render) }
+      end
+
+      describe '#render' do
+        let(:interface) { Vedeu::Interface.new(name: _name, visible: visible) }
+        let(:visible)   { true }
+        let(:geometry)  {
+          Vedeu::Geometry.new(name: _name, x: 1, y: 1, xn: 2, yn: 2)
+        }
+
+        before do
+          Vedeu.interfaces.stubs(:by_name).returns(interface)
+          Vedeu.geometries.stubs(:by_name).returns(geometry)
+        end
+
+        subject { instance.render }
+
+        context 'when the interface is visible' do
+          let(:output) {
+            [
+              [
+                Vedeu::Char.new(value: ' ', position: [1, 1]),
+                Vedeu::Char.new(value: ' ', position: [1, 2]),
+
+              ], [
+                Vedeu::Char.new(value: ' ', position: [2, 1]),
+                Vedeu::Char.new(value: ' ', position: [2, 2]),
+
+              ]
+            ]
+          }
+
+          it { subject.must_equal(output) }
+        end
+
+        context 'when the interface is not visible' do
+          let(:visible) { false }
+
+          it { subject.must_equal([]) }
+        end
+
+      end
+
+    end # NamedInterface
+
+  end # Clear
+
+end # Vedeu

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

@@ -4,12 +4,54 @@ module Vedeu
 
   describe RenderBorder do
 
-    let(:described) { Vedeu::RenderBorder }
-    let(:instance)  { described.new(border) }
-    let(:border)    {
-      Vedeu.border 'Vedeu::RenderBorder' do
-      end
+    let(:described)   { Vedeu::RenderBorder }
+    let(:instance)    { described.new(border) }
+    let(:border)      {
+      Vedeu::Border.new(enabled: enabled,
+                        name: _name).store
     }
+    let(:visible)     { false }
+    let(:enabled)     { false }
+    let(:_name)       { 'Vedeu::RenderBorder' }
+
+    it { described.must_respond_to(:with) }
+
+    describe '#initialize' do
+      it { instance.must_be_instance_of(described) }
+      it { instance.instance_variable_get('@border').must_equal(border) }
+    end
+
+    describe '#render' do
+      before do
+        Vedeu::Geometry.new(name: _name, x: 1, xn: 3, y: 1, yn: 3).store
+        Vedeu::Interface.new(name: _name, visible: visible).store
+      end
+      after do
+        Vedeu.geometries.reset!
+        Vedeu.interfaces.reset!
+        Vedeu.borders.reset!
+      end
+
+      subject { instance.render }
+
+      context 'when the interface is not visible' do
+        it { subject.must_equal([]) }
+      end
+
+      context 'when the interface is visible' do
+        let(:visible) { true }
+
+        context 'when the border is not enabled' do
+          it { subject.must_equal([]) }
+        end
+
+        context 'when the border is enabled' do
+          let(:enabled) { true }
+
+          # it { skip }
+        end
+      end
+    end
 
   end # RenderBorder
 

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

@@ -9,20 +9,47 @@ module Vedeu
       include Vedeu::Registerable
 
       null Vedeu::ModelTestClass
+      real Vedeu::ModelTestClass
 
     end
 
-    describe '.included' do
-      it { RegisterableTestClass.must_respond_to(:null) }
-    end
+    let(:described) { Vedeu::Registerable }
+
+    it { RegisterableTestClass.must_respond_to(:repository) }
+    it { RegisterableTestClass.must_respond_to(:register) }
 
     describe '.null' do
       subject { RegisterableTestClass.new }
 
+      it { RegisterableTestClass.must_respond_to(:null) }
+
       it { subject.must_respond_to(:null_model) }
       it { subject.null_model.must_equal(Vedeu::ModelTestClass) }
     end
 
+    describe '.real' do
+      subject { RegisterableTestClass.new }
+
+      it { RegisterableTestClass.must_respond_to(:real) }
+
+      it { subject.must_respond_to(:model) }
+      it { subject.model.must_equal(Vedeu::ModelTestClass) }
+    end
+
+    describe '.reset' do
+      subject { RegisterableTestClass.reset! }
+
+      before { RegisterableTestClass.stubs(:register) }
+
+      it { RegisterableTestClass.must_respond_to(:reset!) }
+      it { RegisterableTestClass.must_respond_to(:reset) }
+
+      it {
+        RegisterableTestClass.expects(:register)
+        subject
+      }
+    end
+
   end # Registerable
 
 end # Vedeu

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

@@ -10,19 +10,6 @@ module Vedeu
 
     it { described.must_respond_to(:borders) }
 
-    describe '.reset!' do
-      subject { described.reset! }
-
-      before { described.stubs(:register) }
-
-      it { described.must_respond_to(:reset) }
-
-      it {
-        described.expects(:register).with(Vedeu::Border)
-        subject
-      }
-    end
-
   end # Borders
 
 end # Vedeu

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

@@ -9,17 +9,6 @@ module Vedeu
 
     it { described.must_respond_to(:buffers) }
 
-    describe '#reset!' do
-      subject { described.reset! }
-
-      it { described.must_respond_to(:reset) }
-
-      it {
-        described.expects(:register).with(Vedeu::Buffer)
-        subject
-      }
-    end
-
   end # Buffers
 
 end # Vedeu