vedeu 0.6.8 → 0.6.9

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

@@ -2,143 +2,147 @@ require 'test_helper'
 
 module Vedeu
 
-  describe VirtualBuffer do
-
-    let(:described) { Vedeu::VirtualBuffer }
-    let(:instance)  { described.new(height, width, renderer) }
-    let(:height)    { 3 }
-    let(:width)     { 3 }
-    let(:renderer)  { Vedeu::Renderers::HTML.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@height').must_equal(3) }
-      it { instance.instance_variable_get('@width').must_equal(3) }
-      it { instance.instance_variable_get('@renderer').must_equal(renderer) }
-    end
-
-    describe 'accessors' do
-      it { instance.must_respond_to(:renderer) }
-      it { instance.must_respond_to(:renderer=) }
-      it { instance.must_respond_to(:height) }
-      it { instance.must_respond_to(:width) }
-    end
-
-    describe '.output' do
-      let(:data) {}
-
-      before do
-        Vedeu.stubs(:width).returns(3)
-        Vedeu.stubs(:height).returns(3)
-      end
+  module Buffers
 
-      subject { described.output(data) }
+    describe VirtualBuffer do
 
-      it { subject.must_be_instance_of(Array) }
-    end
+      let(:described) { Vedeu::Buffers::VirtualBuffer }
+      let(:instance)  { described.new(height, width, renderer) }
+      let(:height)    { 3 }
+      let(:width)     { 3 }
+      let(:renderer)  { Vedeu::Renderers::HTML.new }
 
-    describe '#cells' do
-      before do
-        Vedeu.stubs(:width).returns(3)
-        Vedeu.stubs(:height).returns(3)
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@height').must_equal(3) }
+        it { instance.instance_variable_get('@width').must_equal(3) }
+        it { instance.instance_variable_get('@renderer').must_equal(renderer) }
       end
 
-      subject { instance.cells }
+      describe 'accessors' do
+        it { instance.must_respond_to(:renderer) }
+        it { instance.must_respond_to(:renderer=) }
+        it { instance.must_respond_to(:height) }
+        it { instance.must_respond_to(:width) }
+      end
 
-      it { subject.must_be_instance_of(Array) }
-      it { subject.size.must_equal(3) }
-      it { subject.flatten.size.must_equal(9) }
-    end
+      describe '.output' do
+        let(:data) {}
 
-    describe '#read' do
-      subject { instance.read(y, x) }
+        before do
+          Vedeu.stubs(:width).returns(3)
+          Vedeu.stubs(:height).returns(3)
+        end
 
-      context 'when x is out of bounds' do
-        let(:y) { 1 }
-        let(:x) { 5 }
+        subject { described.output(data) }
 
-        it { subject.must_equal([]) }
+        it { subject.must_be_instance_of(Array) }
       end
 
-      context 'when y is out of bounds' do
-        let(:y) { 5 }
-        let(:x) { 1 }
+      describe '#cells' do
+        before do
+          Vedeu.stubs(:width).returns(3)
+          Vedeu.stubs(:height).returns(3)
+        end
 
-        it { subject.must_equal([]) }
-      end
+        subject { instance.cells }
 
-      context 'when both x and y are out of bounds' do
-        let(:y) { 5 }
-        let(:x) { 5 }
-
-        it { subject.must_equal([]) }
+        it { subject.must_be_instance_of(Array) }
+        it { subject.size.must_equal(3) }
+        it { subject.flatten.size.must_equal(9) }
       end
 
-      context 'when x and y are in bounds' do
-        let(:y) { 0 }
-        let(:x) { 2 }
+      describe '#read' do
+        subject { instance.read(y, x) }
 
-        it { subject.must_be_instance_of(Vedeu::Models::Cell) }
-      end
-    end
+        context 'when x is out of bounds' do
+          let(:y) { 1 }
+          let(:x) { 5 }
 
-    describe '#output' do
-      it { instance.must_respond_to(:output) }
-    end
+          it { subject.must_equal([]) }
+        end
 
-    describe '#render' do
-      before do
-        Vedeu.stubs(:width).returns(3)
-        Vedeu.stubs(:height).returns(3)
-      end
+        context 'when y is out of bounds' do
+          let(:y) { 5 }
+          let(:x) { 1 }
 
-      subject { instance.render }
+          it { subject.must_equal([]) }
+        end
 
-      it { subject.must_be_instance_of(String) }
-    end
+        context 'when both x and y are out of bounds' do
+          let(:y) { 5 }
+          let(:x) { 5 }
 
-    describe '#reset' do
-      subject { instance.reset }
+          it { subject.must_equal([]) }
+        end
 
-      it { subject.must_be_instance_of(Array) }
+        context 'when x and y are in bounds' do
+          let(:y) { 0 }
+          let(:x) { 2 }
 
-      it { instance.must_respond_to(:clear) }
-    end
+          it { subject.must_be_instance_of(Vedeu::Models::Cell) }
+        end
+      end
 
-    describe '#write' do
-      let(:data) { Vedeu::Views::Char.new(value: 'a') }
+      describe '#output' do
+        it { instance.must_respond_to(:output) }
+      end
 
-      subject { instance.write(y, x, data) }
+      describe '#render' do
+        before do
+          Vedeu.stubs(:width).returns(3)
+          Vedeu.stubs(:height).returns(3)
+        end
 
-      context 'when x is out of bounds' do
-        let(:y) { 1 }
-        let(:x) { 5 }
+        subject { instance.render }
 
-        it { subject.must_equal(false) }
+        it { subject.must_be_instance_of(String) }
       end
 
-      context 'when y is out of bounds' do
-        let(:y) { 5 }
-        let(:x) { 1 }
+      describe '#reset' do
+        subject { instance.reset }
+
+        it { subject.must_be_instance_of(Array) }
 
-        it { subject.must_equal(false) }
+        it { instance.must_respond_to(:clear) }
       end
 
-      context 'when both x and y are out of bounds' do
-        let(:y) { 5 }
-        let(:x) { 5 }
+      describe '#write' do
+        let(:data) { Vedeu::Views::Char.new(value: 'a') }
 
-        it { subject.must_equal(false) }
-      end
+        subject { instance.write(y, x, data) }
+
+        context 'when x is out of bounds' do
+          let(:y) { 1 }
+          let(:x) { 5 }
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'when y is out of bounds' do
+          let(:y) { 5 }
+          let(:x) { 1 }
 
-      context 'when x and y are in bounds' do
-        let(:y) { 0 }
-        let(:x) { 2 }
+          it { subject.must_equal(false) }
+        end
 
-        it { subject.must_equal(true) }
+        context 'when both x and y are out of bounds' do
+          let(:y) { 5 }
+          let(:x) { 5 }
+
+          it { subject.must_equal(false) }
+        end
+
+        context 'when x and y are in bounds' do
+          let(:y) { 0 }
+          let(:x) { 2 }
+
+          it { subject.must_equal(true) }
+        end
       end
-    end
 
-  end # VirtualBuffer
+    end # VirtualBuffer
+
+  end # Buffers
 
 end # Vedeu

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

@@ -2,68 +2,72 @@ require 'test_helper'
 
 module Vedeu
 
-  describe VirtualBuffers do
+  module Buffers
 
-    let(:described) { Vedeu::VirtualBuffers }
+    describe VirtualBuffers do
 
-    before { described.clear }
+      let(:described) { Vedeu::Buffers::VirtualBuffers }
 
-    describe '#retrieve' do
-      subject { described.retrieve }
+      before { described.clear }
 
-      context 'when no buffers are stored' do
-        it { subject.must_be_instance_of(NilClass) }
-      end
+      describe '#retrieve' do
+        subject { described.retrieve }
 
-      context 'when buffers are stored' do
-        let(:buffer) { [[Vedeu::Views::Char.new]] }
+        context 'when no buffers are stored' do
+          it { subject.must_be_instance_of(NilClass) }
+        end
 
-        before { described.store(buffer) }
+        context 'when buffers are stored' do
+          let(:buffer) { [[Vedeu::Views::Char.new]] }
 
-        it { subject.must_be_instance_of(Array) }
+          before { described.store(buffer) }
 
-        it { subject.must_equal(buffer) }
+          it { subject.must_be_instance_of(Array) }
 
-        it 'removes the stored buffer from the storage' do
-          described.size.must_equal(1)
-          subject
-          described.size.must_equal(0)
+          it { subject.must_equal(buffer) }
+
+          it 'removes the stored buffer from the storage' do
+            described.size.must_equal(1)
+            subject
+            described.size.must_equal(0)
+          end
         end
       end
-    end
 
-    describe '#store' do
-      let(:data) { :data }
+      describe '#store' do
+        let(:data) { :data }
 
-      subject { described.store(data) }
+        subject { described.store(data) }
 
-      it { subject.must_be_instance_of(Array) }
+        it { subject.must_be_instance_of(Array) }
 
-      it { subject.must_equal([:data]) }
+        it { subject.must_equal([:data]) }
 
-      it 'adds the buffer (data) to the storage' do
-        described.size.must_equal(0)
-        subject
-        described.size.must_equal(1)
+        it 'adds the buffer (data) to the storage' do
+          described.size.must_equal(0)
+          subject
+          described.size.must_equal(1)
+        end
       end
-    end
 
-    describe '#size' do
-      subject { described.size }
+      describe '#size' do
+        subject { described.size }
 
-      it { subject.must_be_instance_of(Fixnum) }
-    end
+        it { subject.must_be_instance_of(Fixnum) }
+      end
+
+      describe '#clear' do
+        subject { described.clear }
 
-    describe '#clear' do
-      subject { described.clear }
+        it { subject.must_be_instance_of(Array) }
 
-      it { subject.must_be_instance_of(Array) }
+        it { subject.must_be_empty }
 
-      it { subject.must_be_empty }
+        it { described.must_respond_to(:reset) }
+      end
 
-      it { described.must_respond_to(:reset) }
-    end
+    end # VirtualBuffers
 
-  end # VirtualBuffers
+  end # Buffers
 
 end # Vedeu

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

@@ -170,9 +170,9 @@ module Vedeu
       describe '#background=' do
         let(:_value) { '#000000' }
 
-        subject { instance.background = (_value) }
+        subject { instance.public_send(:background=, _value) }
 
-        it { subject.must_equal(_value) }
+        it { subject.must_be_instance_of(Vedeu::Colours::Background) }
       end
 
       describe '#eql?' do
@@ -192,9 +192,9 @@ module Vedeu
       describe '#foreground=' do
         let(:_value) { '#ff0000' }
 
-        subject { instance.foreground = (_value) }
+        subject { instance.public_send(:foreground=, _value) }
 
-        it { subject.must_equal(_value) }
+        it { subject.must_be_instance_of(Vedeu::Colours::Foreground) }
       end
 
       describe '#to_s' do

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

@@ -79,7 +79,7 @@ module Vedeu
         }
 
         before do
-          Vedeu::Output.stubs(:render).
+          Vedeu::Output::Output.stubs(:render).
             with(hide_cursor).returns(hide_cursor)
         end
 
@@ -205,7 +205,7 @@ module Vedeu
         }
 
         before do
-          Vedeu::Output.stubs(:render).
+          Vedeu::Output::Output.stubs(:render).
             with(show_cursor).returns(show_cursor)
         end
 

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

@@ -15,9 +15,9 @@ module Vedeu
 
         context 'when there are cursors are defined' do
           before do
-            Vedeu::Focus.reset
+            Vedeu::Models::Focus.reset
             Vedeu.cursors.reset
-            Vedeu::Focus.add('Vedeu.cursor')
+            Vedeu::Models::Focus.add('Vedeu.cursor')
             Vedeu::Cursors::Cursor.new(name: 'Vedeu.cursor').store
           end
 
@@ -26,7 +26,7 @@ module Vedeu
 
         context 'when there are no cursors defined' do
           before do
-            Vedeu::Focus.reset
+            Vedeu::Models::Focus.reset
             Vedeu.cursors.reset
           end
 

data/test/lib/vedeu/distributed/subprocess_test.rb

@@ -2,43 +2,47 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Subprocess do
+  module Distributed
 
-    let(:described)   { Vedeu::Subprocess }
-    let(:instance)    { described.new(application) }
-    let(:application) {}
+    describe Subprocess do
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it do
-        instance.instance_variable_get('@application').must_equal(application)
-      end
-      it { instance.instance_variable_get('@pid').must_equal(nil) }
-    end
+      let(:described)   { Vedeu::Distributed::Subprocess }
+      let(:instance)    { described.new(application) }
+      let(:application) {}
 
-    describe '.execute!' do
-      it { described.must_respond_to(:execute!) }
-    end
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it do
+          instance.instance_variable_get('@application').must_equal(application)
+        end
+        it { instance.instance_variable_get('@pid').must_equal(nil) }
+      end
 
-    describe '#execute!' do
-      it { instance.must_respond_to(:execute!) }
-    end
+      describe '.execute!' do
+        it { described.must_respond_to(:execute!) }
+      end
 
-    describe '#kill' do
-      before do
-        Process.stubs(:kill)
-        File.stubs(:unlink)
+      describe '#execute!' do
+        it { instance.must_respond_to(:execute!) }
       end
 
-      subject { instance.kill }
+      describe '#kill' do
+        before do
+          Process.stubs(:kill)
+          File.stubs(:unlink)
+        end
+
+        subject { instance.kill }
+
+        it {
+          Process.expects(:kill)
+          File.expects(:unlink)
+          subject
+        }
+      end
 
-      it {
-        Process.expects(:kill)
-        File.expects(:unlink)
-        subject
-      }
-    end
+    end # Subprocess
 
-  end # Subprocess
+  end # Distributed
 
 end # Vedeu