vedeu 0.4.13 → 0.4.14

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

@@ -5,8 +5,17 @@ module Vedeu
   describe Buffer do
 
     let(:described)   { Vedeu::Buffer }
-    let(:instance)    { described.new(buffer_name, back, front, previous, repository) }
-    let(:buffer_name) { 'krypton' }
+    let(:instance)    { described.new(attributes) }
+    let(:attributes)  {
+      {
+        name:       _name,
+        back:       back,
+        front:      front,
+        previous:   previous,
+        repository: repository,
+      }
+    }
+    let(:_name) { 'krypton' }
     let(:back)        {}
     let(:front)       {}
     let(:previous)    {}
@@ -16,11 +25,13 @@ module Vedeu
 
     describe '#initialize' do
       it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(buffer_name) }
+      it { instance.instance_variable_get('@name').must_equal(_name) }
       it { instance.instance_variable_get('@back').must_equal(back) }
       it { instance.instance_variable_get('@front').must_equal(front) }
       it { instance.instance_variable_get('@previous').must_equal(previous) }
-      it { instance.instance_variable_get('@repository').must_equal(Vedeu.buffers) }
+      it do
+        instance.instance_variable_get('@repository').must_equal(Vedeu.buffers)
+      end
     end
 
     describe '#add' do
@@ -52,136 +63,101 @@ module Vedeu
       end
     end
 
-    describe '#content' do
-      subject { instance.content }
-
-      it { subject.must_be_instance_of(Array) }
-
-      context 'when there is content on the back buffer' do
-        let(:back) {
-        Vedeu.interface 'buffer' do
-          lines do
-            line 'old_back'
-          end
-        end
-        }
-        let(:buffer) { :back }
-
-        it { subject.must_equal([back]) }
-      end
-
-      context 'when there is no content on the back buffer' do
-        let(:buffer) { :back }
-
-        it { subject.must_equal([]) }
-      end
-
-      context 'when there is no content on the back buffer' do
-        let(:back) {}
-        let(:buffer) { :back }
-
-        it { subject.must_equal([]) }
-      end
-
-      context 'when there is content on the front buffer' do
-        let(:buffer) { :front }
-        let(:front) {
-          Vedeu.interface 'buffer' do
-            lines do
-              line 'front'
-            end
-          end
-        }
-
-        it { subject.must_equal([front]) }
-      end
-
-      context 'when there is no content on the front buffer' do
-        let(:buffer) { :front }
-
-        it { subject.must_equal([]) }
-      end
-
-      context 'when there is no content on the front buffer' do
-        let(:buffer) { :front }
-        let(:front)  {}
-
-        it { subject.must_equal([]) }
-      end
-
-      context 'when there is content on the previous buffer' do
-        let(:buffer) { :previous }
-        let(:previous) {
-          Vedeu.interface 'buffer' do
-            lines do
-              line 'old_back'
-            end
-          end
-        }
-
-        it { subject.must_equal([previous]) }
-      end
-
-      context 'when there is no content on the previous buffer' do
-        let(:buffer) { :previous }
-
-        it { subject.must_equal([]) }
-      end
-
-      context 'when there is no content on the previous buffer' do
-        let(:buffer)   { :previous }
-        let(:previous) {}
-
-        it { subject.must_equal([]) }
-      end
-    end
-
-    describe '#swap' do
-      subject { instance.swap }
-
-      context 'when there is new content on the back buffer' do
-        let(:back) {
-          Vedeu.interface 'buffer' do
-            lines do
-              line 'back'
-            end
-          end
-        }
-        let(:front) {
-          Vedeu.interface 'buffer' do
-            lines do
-              line 'front'
-            end
-          end
-        }
-        let(:previous) {
-          Vedeu.interface 'buffer' do
-            lines do
-              line 'previous'
-            end
-          end
-        }
-
-        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
-          instance.previous.must_equal(front)
-        end
-
-        it 'replaces the front buffer with the back buffer' do
-          subject
-          instance.front.must_equal(back)
-        end
-
-        it 'replaces the back buffer with an empty buffer' do
-          subject
-          instance.back.must_equal(nil)
-        end
-      end
-    end
+    # describe '#content' do
+    #   subject { instance.content }
+
+    #   it { subject.must_be_instance_of(Array) }
+
+    #   context 'when there is content on the back buffer' do
+    #     before { Vedeu::Output.stubs(:render) }
+
+    #     let(:back) {
+    #       Vedeu.interface 'buffer' do
+    #         lines do
+    #           line 'old_back'
+    #         end
+    #       end
+    #     }
+    #     let(:front) {
+    #       Vedeu.interface 'buffer' do
+    #         lines do
+    #           line 'front'
+    #         end
+    #       end
+    #     }
+    #     let(:previous) {
+    #       Vedeu.interface 'buffer' do
+    #         lines do
+    #           line 'previous'
+    #         end
+    #       end
+    #     }
+    #     let(:buffer) { :back }
+
+    #     it { subject.must_equal([back]) }
+
+    #     it 'replaces the previous buffer with the front buffer' do
+    #       subject
+    #       instance.previous.must_equal(front)
+    #     end
+
+    #     it 'replaces the front buffer with the back buffer' do
+    #       subject
+    #       instance.front.must_equal(back)
+    #     end
+
+    #     it 'replaces the back buffer with an empty buffer' do
+    #       subject
+    #       instance.back.must_equal(nil)
+    #     end
+    #   end
+
+    #   context 'when there is no content on the back buffer' do
+    #     let(:buffer) { :back }
+
+    #     it { subject.must_equal([]) }
+    #   end
+
+    #   context 'when there is content on the front buffer' do
+    #     before { Vedeu::Output.stubs(:render) }
+    #     let(:buffer) { :front }
+    #     let(:front) {
+    #       Vedeu.interface 'buffer' do
+    #         lines do
+    #           line 'front'
+    #         end
+    #       end
+    #     }
+
+    #     it { subject.must_equal([front]) }
+    #   end
+
+    #   context 'when there is no content on the front buffer' do
+    #     let(:buffer) { :front }
+
+    #     it { subject.must_equal([]) }
+    #   end
+
+    #   context 'when there is content on the previous buffer' do
+    #     before { Vedeu::Output.stubs(:render) }
+    #     let(:buffer) { :previous }
+    #     let(:previous) {
+    #       Vedeu.interface 'buffer' do
+    #         lines do
+    #           line 'old_back'
+    #         end
+    #       end
+    #     }
+
+    #     it { subject.must_equal([previous]) }
+    #   end
+
+    #   context 'when there is no content on the previous buffer' do
+    #     let(:buffer) { :previous }
+
+    #     it { subject.must_equal([]) }
+    #   end
+    # end
 
   end # Buffer
 

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

@@ -6,10 +6,18 @@ module Vedeu
     include Vedeu::Model
     include Vedeu::DisplayBuffer
 
+    def colour
+      Vedeu::Colour.new(background: '#000000', foreground: '#ffffff')
+    end
+
     def name
       'test_interface_model'
     end
 
+    def style
+      Vedeu::Style.new(:normal)
+    end
+
     private
 
     def repository

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

@@ -279,7 +279,11 @@ module Vedeu
           methods_and_keys.each do |meth, _|
             invalid_params.each do |param|
               context 'when the parameter is invalid' do
-                it { proc { Vedeu.configure { send(meth, param) } }.must_raise(InvalidSyntax) }
+                it {
+                  proc {
+                    Vedeu.configure { send(meth, param) }
+                  }.must_raise(InvalidSyntax)
+                }
               end
             end
           end

data/test/lib/vedeu/configuration/configuration_test.rb

@@ -19,12 +19,10 @@ module Vedeu
 
     describe '.default_system_keys' do
       it 'returns the default system keys' do
-        Configuration.default_system_keys.must_equal({
-          exit:        'q',
-          focus_next:  :tab,
-          focus_prev:  :shift_tab,
-          mode_switch: :escape,
-        })
+        Configuration.default_system_keys.must_equal(exit:        'q',
+                                                     focus_next:  :tab,
+                                                     focus_prev:  :shift_tab,
+                                                     mode_switch: :escape,)
       end
     end
 

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

@@ -13,7 +13,7 @@ module Vedeu
         ox:         ox,
         oy:         oy,
         repository: repository,
-        state:      state,
+        visible:    visible,
         x:          x,
         y:          y,
       }
@@ -22,32 +22,39 @@ module Vedeu
     let(:ox)         { 3 }
     let(:oy)         { 2 }
     let(:repository) { Vedeu.cursors }
-    let(:state)      { :show }
+    let(:visible)    { true }
     let(:x)          { 19 }
     let(:y)          { 8 }
 
     describe '#initialize' do
-      it { instance.must_be_instance_of(Cursor) }
-      it { instance.instance_variable_get('@name').must_equal('silver') }
-      it { instance.instance_variable_get('@ox').must_equal(3) }
-      it { instance.instance_variable_get('@oy').must_equal(2) }
-      it { instance.instance_variable_get('@repository').must_equal(Vedeu.cursors) }
-      it { instance.instance_variable_get('@state').must_be_instance_of(Vedeu::Visible) }
-      it { instance.instance_variable_get('@x').must_equal(19) }
-      it { instance.instance_variable_get('@y').must_equal(8) }
-
-      it { instance.instance_variable_get('@position').must_be_instance_of(Vedeu::Position) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Cursor) }
+      it { subject.instance_variable_get('@name').must_equal('silver') }
+      it { subject.instance_variable_get('@ox').must_equal(3) }
+      it { subject.instance_variable_get('@oy').must_equal(2) }
+      it { subject.instance_variable_get('@repository').must_equal(repository) }
+      it { subject.instance_variable_get('@visible').must_equal(true) }
+      it { subject.instance_variable_get('@x').must_equal(19) }
+      it { subject.instance_variable_get('@y').must_equal(8) }
+
+      it do
+        subject.instance_variable_get('@position').
+          must_be_instance_of(Vedeu::Position)
+      end
     end
 
     describe '#inspect' do
       subject { instance.inspect }
 
       it { subject.must_be_instance_of(String) }
-      it { subject.must_equal("<Vedeu::Cursor (silver, visible, x:19, y:8, ox:3, oy:2)>") }
+      it { subject.must_equal(
+        '<Vedeu::Cursor (silver, true, x:19, y:8, ox:3, oy:2)>'
+      ) }
     end
 
     describe '#to_s' do
-      let(:state) { true }
+      let(:visible) { true }
 
       subject { instance.to_s }
 
@@ -60,7 +67,7 @@ module Vedeu
       end
 
       context 'when the cursor is invisible' do
-        let(:state) { false }
+        let(:visible) { false }
 
         it 'returns the invisible cursor escape sequence with position' do
           subject.must_equal("\e[8;19H\e[?25l")
@@ -74,8 +81,9 @@ module Vedeu
           end
         }
 
-        it 'returns the escape sequence to position and set the visibility of ' \
-           'the cursor and returns to that position after yielding the block' do
+        it 'returns the escape sequence to position and set the visibility ' \
+           'of the cursor and returns to that position after yielding the '  \
+           'block' do
           subject.must_equal("\e[8;19H\e[?25h\e[8;19H\e[?25h")
         end
       end

data/test/lib/vedeu/cursor/move_test.rb

@@ -7,12 +7,12 @@ module Vedeu
     let(:described) { Vedeu::Move }
     let(:instance)  { described.new(cursor, interface, dy, dx) }
     let(:cursor)    {
-      Cursor.new({ name: 'Move',
-                   ox:    ox,
-                   oy:    oy,
-                   state: :show,
-                   x:     x,
-                   y:     y })
+      Cursor.new(name: 'Move',
+                 ox:    ox,
+                 oy:    oy,
+                 visible: true,
+                 x:     x,
+                 y:     y)
     }
     let(:ox)        { 0 }
     let(:oy)        { 0 }
@@ -75,7 +75,7 @@ module Vedeu
         Vedeu.cursors.reset
 
         interface_with_border
-        Vedeu::Cursor.new({ name: 'manganese', oy: 2, ox: 3, x: 8, y: 7 }).store
+        Vedeu::Cursor.new(name: 'manganese', oy: 2, ox: 3, x: 8, y: 7).store
       end
 
       subject { Move.by_name(direction, _name) }

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

@@ -19,7 +19,7 @@ module Vedeu
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }
-        it { instance.instance_variable_get('@uri').must_equal('druby://localhost:21420') }
+        it { instance.instance_variable_get('@uri').must_equal(uri) }
       end
 
       describe '.connect' do

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

@@ -12,7 +12,9 @@ module Vedeu
       subject { instance }
 
       it { subject.must_be_instance_of(Vedeu::Subprocess) }
-      it { subject.instance_variable_get('@application').must_equal(application) }
+      it do
+        subject.instance_variable_get('@application').must_equal(application)
+      end
     end
 
   end # Subprocess

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

@@ -16,7 +16,7 @@ module Vedeu
 
         it { subject.must_be_instance_of(described) }
         it { subject.instance_variable_get('@host').must_equal('localhost') }
-        it { subject.instance_variable_get('@port').must_equal(21420) }
+        it { subject.instance_variable_get('@port').must_equal(21_420) }
       end
 
       describe '#host' do
@@ -41,23 +41,23 @@ module Vedeu
         subject { instance.port }
 
         context 'when the port has been defined by the client application' do
-          let(:port) { 40000 }
+          let(:port) { 40_000 }
 
           it 'returns the port' do
-            subject.must_equal(40000)
+            subject.must_equal(40_000)
           end
         end
 
         context 'when the port has not been redefined' do
           it 'returns the default port' do
-            subject.must_equal(21420)
+            subject.must_equal(21_420)
           end
         end
       end
 
       describe '#to_s' do
         let(:host) { 'myserver' }
-        let(:port) { 40000 }
+        let(:port) { 40_000 }
 
         subject { instance.to_s }
 

data/test/lib/vedeu/dsl/components/geometry_test.rb

@@ -79,6 +79,25 @@ module Vedeu
         end
       end
 
+      # describe '#use' do
+      #   subject { 
+      #     Vedeu::Geometry.build({ name: 'hydrogen' }) { use 'helium' }
+      #   }
+
+      #   context 'when the named geometry does not exist' do
+      #   end
+
+      #   context 'when the named geometry exists' do
+      #     before do
+      #       Vedeu::Geometry.build({ name: 'helium', x: 5 }).store
+      #     end
+
+      #     it { subject.must_be_instance_of(Vedeu::Geometry) }
+      #     it { subject.name.must_equal('hydrogen') }
+      #     it { subject.x.must_equal(5) }
+      #   end
+      # end
+
       describe '#width' do
         subject { Vedeu::Geometry.build({}) { width 25 } }
 
@@ -211,6 +230,18 @@ module Vedeu
         subject { Vedeu::Geometry.build({}) { xn 15 } }
 
         it { subject.xn.must_equal(15) }
+
+        context 'when a block is given' do
+          subject {
+            Vedeu::Geometry.build({}) do
+              xn do
+                8 + 8
+              end
+            end
+          }
+
+          it { subject.xn.must_equal(16) }
+        end
       end
 
       describe '#yn' do
@@ -219,6 +250,18 @@ module Vedeu
         subject { Vedeu::Geometry.build({}) { yn 8 } }
 
         it { subject.yn.must_equal(8) }
+
+        context 'when a block is given' do
+          subject {
+            Vedeu::Geometry.build({}) do
+              yn do
+                5 + 3
+              end
+            end
+          }
+
+          it { subject.yn.must_equal(8) }
+        end
       end
 
     end # Geometry

data/test/lib/vedeu/dsl/components/keymap_test.rb

@@ -8,7 +8,7 @@ module Vedeu
 
       let(:described) { Vedeu::DSL::Keymap }
       let(:instance)  { described.new(model) }
-      let(:model)     { Vedeu::Keymap.new({ name: '_test_' }) }
+      let(:model)     { Vedeu::Keymap.new(name: '_test_') }
 
       describe '#initialize' do
         it { instance.must_be_instance_of(described) }

data/test/lib/vedeu/dsl/composition_test.rb

@@ -39,15 +39,16 @@ module Vedeu
         let(:content)  { "Hydrogen\nCarbon\nOxygen\nNitrogen" }
         let(:as_lines) {
           [
-            Vedeu::Line.new({ streams: [Vedeu::Stream.new({ value: 'Hydrogen' })] }),
-            Vedeu::Line.new({ streams: [Vedeu::Stream.new({ value: 'Carbon' })] }),
-            Vedeu::Line.new({ streams: [Vedeu::Stream.new({ value: 'Oxygen' })] }),
-            Vedeu::Line.new({ streams: [Vedeu::Stream.new({ value: 'Nitrogen' })] })
+            Vedeu::Line.new(streams: [Vedeu::Stream.new(value: 'Hydrogen')]),
+            Vedeu::Line.new(streams: [Vedeu::Stream.new(value: 'Carbon')]),
+            Vedeu::Line.new(streams: [Vedeu::Stream.new(value: 'Oxygen')]),
+            Vedeu::Line.new(streams: [Vedeu::Stream.new(value: 'Nitrogen')])
           ]
         }
 
         before do
-          Vedeu::Template.expects(:parse).with(object, filename).returns(content)
+          Vedeu::Template.expects(:parse).
+            with(object, filename).returns(content)
         end
 
         subject { instance.template_for(_name, filename, object) }