vedeu 0.2.12 → 0.3.0

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

@@ -4,62 +4,188 @@ module Vedeu
 
   describe Viewport do
 
-    let(:described) { Viewport.new(interface) }
+    let(:described) { Vedeu::Viewport }
+    let(:instance)  { described.new(interface) }
     let(:interface) {
-      Interface.new({
-        name:     'fluorine',
-        geometry: {
-          width:  30,
-          height: 2,
-        },
-        lines: [
-          {
-            streams: [{
-              text: 'Something interesting ',
-            },{
-              text: 'on this line ',
-            },{
-              text: 'would be cool, eh?'
-            }]
-          }, {
-            streams: [{
-              text: 'Maybe a lyric, a little ditty ',
-            },{
-              text: 'to help you unwind.',
-            }]
-          }
-        ]
-      })
+      Vedeu::Interface.build do
+        geometry do
+          height 3
+          width 3
+        end
+        lines do
+          line 'barium'
+          line 'carbon'
+          line 'helium'
+          line 'iodine'
+          line 'nickel'
+          line 'osmium'
+        end
+        name 'lithium'
+      end
     }
 
     describe '#initialize' do
-      it { return_type_for(described, Viewport) }
-      it { assigns(described, '@interface', interface) }
-      it { assigns(described, '@top', 0) }
-      it { assigns(described, '@left', 0) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Viewport) }
+      it { subject.instance_variable_get('@interface').must_equal(interface) }
     end
 
     describe '.show' do
-      it { return_type_for(Viewport.show(interface), Array) }
+      subject { described.show(interface) }
 
-      context 'when there is no content' do
-        before { interface.stubs(:content).returns([]) }
+      it { subject.must_be_instance_of(Array) }
+    end
 
-        it 'returns an empty collection' do
-          Viewport.show(interface).must_equal([])
-        end
+    describe '#show' do
+      let(:cursor) { Cursor.new(cursor_attributes) }
+      let(:cursor_attributes) {
+        { name: 'lithium', ox: ox, oy: oy, state: true, x: x, y: y }
+      }
+      let(:lines)  { [] }
+      let(:ox)     { 0 }
+      let(:oy)     { 0 }
+      let(:x)      { 1 }
+      let(:y)      { 1 }
+
+      before do
+        interface.stubs(:cursor).returns(cursor)
       end
 
-      context 'when there is content, it returns only the visible content '  \
-              'determined by the geometry of the interface and the current ' \
-              'offset stored' do
-        it 'returns a collection of lines, each a collection of characters' do
-          Viewport.show(interface).must_equal(
-            [
-              ['S', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g', ' ', 'i', 'n', 't', 'e', 'r', 'e', 's', 't', 'i', 'n', 'g', ' ', 'o', 'n', ' ', 't', 'h', 'i', 's', ' '],
-              ['M', 'a', 'y', 'b', 'e', ' ', 'a', ' ', 'l', 'y', 'r', 'i', 'c', ',', ' ', 'a', ' ', 'l', 'i', 't', 't', 'l', 'e', ' ', 'd', 'i', 't', 't', 'y', ' ']
-            ]
-          )
+      subject { instance.show }
+
+      it { subject.must_be_instance_of(Array) }
+
+      # context 'when there is no content' do
+      #   before { interface.stubs(:lines).returns([]) }
+
+      #   it { subject.must_equal([]) }
+      # end
+
+      context 'when there is content' do
+        context "when the cursor's y position is outside the viewable area - negative" do
+          let(:ox) { -4 }
+          let(:oy) { -4 }
+
+          it "scrolls the content the correct position" do
+            subject.must_equal(
+              [
+                ["b", "a", "r"],
+                ["c", "a", "r"],
+                ["h", "e", "l"]
+              ]
+            )
+          end
+
+          it { instance.to_s.must_equal("bar\ncar\nhel") }
+        end
+
+        context "when the cursor's y position is inside the viewable area" do
+          context "when there is not enough content to fill the height" do
+            let(:ox) { 3 }
+            let(:oy) { 7 }
+
+            it "is padded with spaces" do
+              subject.must_equal(
+                [
+                  ["n", "i", "c"],
+                  ["o", "s", "m"],
+                  [" ", " ", " "]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("nic\nosm\n   ") }
+          end
+
+          context "when there is more content than the height" do
+            let(:ox) { 3 }
+            let(:oy) { 3 }
+
+            it "is cropped to show only that which fits" do
+              subject.must_equal(
+                [
+                  ["b", "a", "r"],
+                  ["c", "a", "r"],
+                  ["h", "e", "l"]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("bar\ncar\nhel") }
+          end
+        end
+
+        context "when the cursor's x position is outside the viewable area" do
+          context "but inside the content" do
+            let(:ox) { 6 }
+            let(:oy) { 6 }
+
+            it "scrolls the content the correct position" do
+              subject.must_equal(
+                [
+                  ["i", "n", "e"],
+                  ["k", "e", "l"],
+                  ["i", "u", "m"]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("ine\nkel\nium") }
+          end
+
+          context "and outside the content" do
+            let(:ox) { 7 }
+            let(:oy) { 7 }
+
+            it "scrolls the content the correct position" do
+              subject.must_equal(
+                [
+                  ["e", "l", " "],
+                  ["u", "m", " "],
+                  [" ", " ", " "]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("el \num \n   ") }
+          end
+        end
+
+        context "when the cursor's x position is inside the viewable area" do
+          context "when there is not enough content to fill the width" do
+            let(:ox) { 7 }
+            let(:oy) { 3 }
+
+            it "is padded with spaces" do
+              subject.must_equal(
+                [
+                  ["u", "m", " "],
+                  ["o", "n", " "],
+                  ["u", "m", " "]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("um \non \num ") }
+          end
+
+          context "when there is more content than the width" do
+            let(:ox) { 3 }
+            let(:oy) { 3 }
+
+            it "is cropped to show only that which fits" do
+              subject.must_equal(
+                [
+                  ["b", "a", "r"],
+                  ["c", "a", "r"],
+                  ["h", "e", "l"]
+                ]
+              )
+            end
+
+            it { instance.to_s.must_equal("bar\ncar\nhel") }
+          end
         end
       end
     end

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

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Writer do
+
+    describe '.[]' do
+      it 'returns a new instance of Writer' do
+        Writer[:null, :file, :screen].must_be_instance_of(Writer)
+      end
+    end
+
+    describe '#initialize' do
+      it 'returns an instance of itself' do
+        writers = :null
+
+        Writer.new(writers).must_be_instance_of(Writer)
+      end
+    end
+
+    # describe '#==' do
+    #   context 'when the two objects are the same' do
+    #     it { skip;subject.must_equal(true) }
+    #   end
+
+    #   context 'when the two objects are not the same' do
+    #     it { skip;subject.must_equal(false) }
+    #   end
+    # end
+
+    # describe '#+' do
+    #   it 'returns the collection of writers' do
+    #     skip
+    #   end
+    # end
+
+    # describe '.write' do
+    #   it 'not sure if this should be here' do
+    #     skip
+    #   end
+    # end
+
+  end # Writer
+
+end # Vedeu

data/test/lib/vedeu/{colours → presentation}/colour_test.rb

@@ -13,12 +13,12 @@ module Vedeu
     }
 
     describe '#initialize' do
-      it { return_type_for(described, Colour) }
-      it { assigns(described, '@attributes', attributes) }
+      it { described.must_be_instance_of(Colour) }
+      it { described.instance_variable_get('@attributes').must_equal(attributes) }
     end
 
     describe '#background' do
-      it { return_type_for(described.background, String) }
+      it { described.background.must_be_instance_of(String) }
 
       it 'returns an escape sequence' do
         Colour.new({
@@ -32,7 +32,7 @@ module Vedeu
     end
 
     describe '#foreground' do
-      it { return_type_for(described.foreground, String) }
+      it { described.foreground.must_be_instance_of(String) }
 
       it 'returns an escape sequence' do
         Colour.new({
@@ -46,7 +46,7 @@ module Vedeu
     end
 
     describe '#to_s' do
-      it { return_type_for(described.to_s, String) }
+      it { described.to_s.must_be_instance_of(String) }
 
       it 'returns an escape sequence' do
         Colour.new({

data/test/lib/vedeu/presentation/presentation_test.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Presentation do
+
+    let(:receiver) { PresentationTestClass.new }
+
+    describe '#colour=' do
+      let(:colour) { Colour.new({ foreground: '#00ff00', background: '#000000' }) }
+
+      subject { receiver.colour=(colour) }
+
+      it { subject.must_be_instance_of(Colour) }
+    end
+
+    describe '#style=' do
+      let(:style) { Style.new('normal') }
+
+      subject { receiver.style=(style) }
+
+      it { subject.must_be_instance_of(Style) }
+    end
+
+    describe '#to_s' do
+      let(:line) { Line.new(
+          [],
+          mock('Interface'),
+          Colour.new({ foreground: '#00ff00', background: '#000000' }),
+          Style.new('normal')
+        )
+      }
+      let(:stream) { Stream.new(stream_value, line, stream_colour, stream_style) }
+      let(:stream_value)  { 'Some text' }
+      let(:stream_colour) { Colour.new({ foreground: '#ff0000', background: '#000000' }) }
+      let(:stream_style)  { Style.new(:underline) }
+
+      it 'returns output' do
+        stream.to_s.must_equal(
+          # - stream colour
+          # - stream style
+          # - stream content
+          # - line style
+          # - line colour
+          "\e[38;2;255;0;0m\e[48;2;0;0;0m"  \
+          "\e[4m"                           \
+          "Some text"                       \
+          "\e[24m\e[22m\e[27m"              \
+          "\e[38;2;0;255;0m\e[48;2;0;0;0m"
+        )
+      end
+    end
+
+  end # Presentation
+
+end # Vedeu

data/test/lib/vedeu/presentation/style_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Style do
+
+    let(:described) { Style }
+
+    describe '#initialize' do
+      subject { described.new('bold') }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@value').must_equal('bold') }
+    end
+
+    describe '#attributes' do
+      subject { described.new('bold').attributes }
+
+      it { subject.must_be_instance_of(Hash) }
+
+      it 'returns an attributes hash for this instance' do
+        subject.must_equal({ style: 'bold' })
+      end
+    end
+
+    describe '#to_s' do
+      let(:value) {}
+
+      subject { described.new(value).to_s }
+
+      it { subject.must_be_instance_of(String) }
+      it { subject.must_equal('') }
+
+      describe 'for a single style' do
+        let(:value) { 'normal' }
+
+        it 'returns an escape sequence' do
+          subject.must_equal("\e[24m\e[22m\e[27m")
+        end
+      end
+
+      describe 'for multiple styles' do
+        let(:value) { ['normal', 'underline'] }
+
+        it 'returns an escape sequence for multiple styles' do
+          subject.must_equal("\e[24m\e[22m\e[27m\e[4m")
+        end
+      end
+
+      describe 'for an unknown style' do
+        let(:value) { 'unknown' }
+
+        it 'returns an empty string for an unknown style' do
+          subject.must_equal('')
+        end
+      end
+
+      describe 'for an empty or nil' do
+        let(:value) { '' }
+
+        it 'returns an empty string for empty or nil' do
+          subject.must_equal('')
+        end
+      end
+    end
+
+  end # Style
+
+end # Vedeu

data/test/lib/vedeu/presentation/translator_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Translator do
+
+    let(:described) { Vedeu::Translator }
+    let(:instance)  { described.new(colour) }
+    let(:colour)    { '#ff0000' }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Translator) }
+      it { subject.instance_variable_get('@colour').must_equal(colour) }
+    end
+
+    describe '#escape_sequence' do
+      subject { instance.escape_sequence }
+
+      context 'when no colour is given' do
+        let(:colour) {}
+
+        it { subject.must_equal('') }
+      end
+
+      context 'when the colour is a terminal named colour; e.g. :red' do
+        let(:colour) { :red }
+
+        it 'raises an exception since the subclasses Background and ' \
+           'Foreground handle this' do
+          proc { subject }.must_raise(NotImplemented)
+        end
+      end
+
+      context 'when the colour is a terminal numbered colour; e.g. 122' do
+        let(:colour) { 122 }
+
+        it 'raises an exception since the subclasses Background and ' \
+           'Foreground handle this' do
+          proc { subject }.must_raise(NotImplemented)
+        end
+      end
+
+      context 'when the colour is a HTML/CSS colour (RGB specified)' do
+        let(:colour) { '#ff0000' }
+
+        it 'raises an exception since the subclasses Background and ' \
+           'Foreground handle this' do
+          proc { subject }.must_raise(NotImplemented)
+        end
+      end
+
+      context 'when the colour is not supported' do
+        let(:colour) { [:not_supported] }
+
+        it { subject.must_equal('') }
+      end
+    end
+
+  end # Translator
+
+end # Vedeu

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

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+module Vedeu
+
+
+
+end # Vedeu

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

@@ -4,163 +4,10 @@ module Vedeu
 
   describe Menus do
 
-    describe ' system events defined by Menus' do
-      let(:collection) { [:sulphur, :gold, :tin, :helium] }
-      let(:instance)   { Vedeu::Menu.new(collection) }
+    describe '.menus' do
+      subject { Vedeu::Menus.menus }
 
-      before do
-        Menus.reset
-        Menus.add({ name:  'elements',
-                    items: collection })
-        Vedeu::Menu.stubs(:new).returns(instance)
-      end
-
-      it '_menu_current_' do
-        Vedeu.trigger(:_menu_current_, 'elements').must_equal(:sulphur)
-      end
-
-      it '_menu_selected_ when no item is selected' do
-        Vedeu.trigger(:_menu_selected_, 'elements').must_equal([nil])
-      end
-
-      it '_menu_selected_ when an item is selected' do
-        Vedeu.trigger(:_menu_next_, 'elements')
-        Vedeu.trigger(:_menu_select_, 'elements')
-        Vedeu.trigger(:_menu_selected_, 'elements').must_equal(:gold)
-      end
-
-      it '_menu_next_' do
-        Vedeu.trigger(:_menu_next_, 'elements').must_equal(
-          [
-            [false, false, :sulphur],
-            [false, true, :gold],
-            [false, false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_prev_' do
-        Vedeu.trigger(:_menu_prev_, 'elements').must_equal(
-          [
-            [false, true, :sulphur],
-            [false, false, :gold],
-            [false, false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_top_' do
-        Vedeu.trigger(:_menu_top_, 'elements').must_equal(
-          [
-            [false, true, :sulphur],
-            [false, false, :gold],
-            [false, false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_bottom_' do
-        Vedeu.trigger(:_menu_bottom_, 'elements').must_equal(
-          [
-            [false, false, :sulphur],
-            [false, false, :gold],
-            [false, false, :tin],
-            [false, true, :helium]
-          ]
-        )
-      end
-
-      it '_menu_select_' do
-        2.times { Vedeu.trigger(:_menu_next_, 'elements') }
-
-        Vedeu.trigger(:_menu_select_, 'elements').must_equal(
-          [
-            [false, false, :sulphur],
-            [false, false, :gold],
-            [true,  true,  :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_deselect_' do
-        Vedeu.trigger(:_menu_deselect_, 'elements').must_equal(
-          [
-            [false, true, :sulphur],
-            [false, false, :gold],
-            [false, false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_items_' do
-        2.times { Vedeu.trigger(:_menu_next_, 'elements') }
-        Vedeu.trigger(:_menu_select_, 'elements')
-        Vedeu.trigger(:_menu_prev_, 'elements')
-
-        Vedeu.trigger(:_menu_items_, 'elements').must_equal(
-          [
-            [false, false, :sulphur],
-            [false, true,  :gold],
-            [true,  false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-
-      it '_menu_view_' do
-        Vedeu.trigger(:_menu_view_, 'elements').must_equal(
-          [
-            [false, true, :sulphur],
-            [false, false, :gold],
-            [false, false, :tin],
-            [false, false, :helium]
-          ]
-        )
-      end
-    end
-
-    describe '#add' do
-      let(:collection) { [:hydrogen, :helium, :beryllium, :lithium] }
-      let(:instance)   { Vedeu::Menu.new(collection) }
-
-      before do
-        Menus.reset
-        Vedeu::Menu.stubs(:new).returns(instance)
-      end
-
-      it 'raises an exception if menu name is empty' do
-        proc { Menus.add({ name: '' }) }.must_raise(MissingRequired)
-      end
-
-      it 'adds the menu to the storage' do
-        Menus.add({ name: 'elements', items: collection })
-        Menus.all.must_equal(
-          {
-            'elements' => { name: 'elements', items: instance }
-          }
-        )
-      end
-    end
-
-    describe '#use' do
-      let(:collection) { [:calcium, :fermium, :nitrogen, :palladium] }
-      let(:instance)   { Vedeu::Menu.new(collection) }
-
-      before do
-        Menus.reset
-        Vedeu::Menu.stubs(:new).returns(instance)
-      end
-
-      it 'returns the Vedeu::Menu instance stored when the named menu exists' do
-        Menus.add({ name: 'elements', items: collection })
-
-        Menus.use('elements').must_equal(instance)
-      end
+      it { subject.must_be_instance_of(Vedeu::Menus) }
     end
 
   end # Menus