vedeu 0.2.11 → 0.2.12

data/test/lib/vedeu/api/helpers_test.rb

@@ -7,9 +7,7 @@ module Vedeu
     describe Helpers do
 
       describe '#background' do
-        it 'returns a Hash' do
-          HelpersTestClass.new.background('#00ff00').must_be_instance_of(Hash)
-        end
+        it { return_type_for(HelpersTestClass.new.background('#00ff00'), Hash) }
 
         it 'returns the value assigned' do
           HelpersTestClass.new.background('#00ff00').must_equal({ background: '#00ff00' })
@@ -21,9 +19,7 @@ module Vedeu
       end
 
       describe '#foreground' do
-        it 'returns a Hash' do
-          HelpersTestClass.new.foreground('#00ff00').must_be_instance_of(Hash)
-        end
+        it { return_type_for(HelpersTestClass.new.foreground('#00ff00'), Hash) }
 
         it 'returns the value assigned' do
           HelpersTestClass.new.foreground('#00ff00').must_equal({ foreground: '#00ff00' })

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

@@ -20,18 +20,19 @@ module Vedeu
             colour foreground: '#aadd00', background: '#222222'
           end.must_equal(
             {
-              name: '',
-              cursor: :hide,
-              group: '',
-              lines: [],
+              border: {},
               colour: {
                 foreground: '#aadd00',
                 background: '#222222'
               },
-              style: '',
-              geometry: {},
+              cursor: :hide,
               delay: 0.0,
+              geometry: {},
+              group: '',
+              lines: [],
+              name: '',
               parent: nil,
+              style: '',
             }
           )
         end
@@ -41,15 +42,16 @@ module Vedeu
             style 'underline'
           end.must_equal(
             {
-              name: '',
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 0.0,
+              geometry: {},
               group: '',
               lines: [],
-              colour: {},
-              style: "underline",
-              geometry: {},
-              delay: 0.0,
+              name: '',
               parent: nil,
+              style: "underline",
             }
           )
         end
@@ -66,17 +68,18 @@ module Vedeu
               name   'my_other_interface'
               y      use('my_interface').south
             end.must_equal({
-              name: "my_other_interface",
-              cursor: :hide,
-              group: '',
-              lines: [],
+              border: {},
               colour: {},
-              style: '',
+              cursor: :hide,
+              delay: 0.0,
               geometry: {
                 y: 11
               },
-              delay: 0.0,
+              group: '',
+              lines: [],
+              name: "my_other_interface",
               parent: nil,
+              style: '',
             })
           end
         end
@@ -87,15 +90,16 @@ module Vedeu
             delay 1.0
           end.must_equal(
             {
-              name: '',
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 1.0,
+              geometry: {},
               group: '',
               lines: [],
-              colour: {},
-              style: '',
-              geometry: {},
-              delay: 1.0,
+              name: '',
               parent: nil,
+              style: '',
             })
         end
 
@@ -105,15 +109,16 @@ module Vedeu
             group 'my_group'
           end.must_equal(
             {
-              name: '',
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 0.0,
+              geometry: {},
               group: "my_group",
               lines: [],
-              colour: {},
-              style: '',
-              geometry: {},
-              delay: 0.0,
+              name: '',
               parent: nil,
+              style: '',
             }
           )
         end
@@ -246,24 +251,25 @@ module Vedeu
           interface.must_be_instance_of(API::Interface)
           interface.attributes.must_equal(
             {
-              name: 'carbon',
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 0.0,
+              geometry: {},
               group: '',
               lines: [
                 {
                   colour: {},
+                  parent: interface.view_attributes,
                   streams: {
                     text: ''
                   },
                   style: [],
-                  parent: interface.view_attributes,
                 }
               ],
-              colour: {},
-              style: '',
-              geometry: {},
-              delay: 0.0,
+              name: 'carbon',
               parent: nil,
+              style: '',
             }
           )
         end
@@ -275,24 +281,25 @@ module Vedeu
           interface.must_be_instance_of(API::Interface)
           interface.attributes.must_equal(
             {
-              name: 'carbon',
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 0.0,
+              geometry: {},
               group: '',
               lines: [
                 {
                   colour: {},
+                  parent: interface.view_attributes,
                   streams: {
                     text: "This is some text..."
                   },
                   style: [],
-                  parent: interface.view_attributes,
                 }
               ],
-              colour: {},
-              style: '',
-              geometry: {},
-              delay: 0.0,
+              name: 'carbon',
               parent: nil,
+              style: '',
             }
           )
         end
@@ -306,26 +313,27 @@ module Vedeu
           interface.must_be_instance_of(API::Interface)
           interface.attributes.must_equal(
             {
-              name: "silicon",
+              border: {},
+              colour: {},
               cursor: :hide,
+              delay: 0.0,
+              geometry: {},
               group: '',
               lines: [
                 {
                   colour: {},
+                  parent: interface.view_attributes,
                   streams: [
                     {
                       text: "This is different text..."
                     }
                   ],
                   style: [],
-                  parent: interface.view_attributes,
                 }
               ],
-              colour: {},
+              name: "silicon",
+              parent: nil,
               style: '',
-              geometry: {},
-              delay: 0.0,
-              parent: nil
             }
           )
         end

data/test/lib/vedeu/api/menu_test.rb

@@ -37,6 +37,12 @@ module Vedeu
         it 'returns an instance of itself' do
           Menu.new.must_be_instance_of(Menu)
         end
+
+        it 'assigns the attributes' do
+          attributes = { name: '', items: [] }
+          subject    = Menu.new(attributes)
+          assigns(subject, '@attributes', attributes)
+        end
       end
 
       describe '#items' do

data/test/lib/vedeu/api/stream_test.rb

@@ -7,9 +7,7 @@ module Vedeu
     describe Stream do
 
       describe '#align' do
-        it 'returns a Symbol' do
-          Stream.new.align(:left).must_be_instance_of(Symbol)
-        end
+        it { return_type_for(Stream.new.align(:left), Symbol) }
 
         it 'returns the value assigned' do
           Stream.new.align(:left).must_equal(:left)

data/test/lib/vedeu/application_test.rb

@@ -4,17 +4,15 @@ module Vedeu
 
   describe Application do
 
+    let(:described) { Application.new }
+
     before { Terminal.stubs(:open).returns(['']) }
 
     describe '.start' do
-      it 'returns an Array' do
-        Application.start.must_be_instance_of(Array)
-      end
+      it { return_type_for(Application.start, Array) }
 
       context 'alias method: .restart' do
-        it 'returns an Array' do
-          Application.restart.must_be_instance_of(Array)
-        end
+        it { return_type_for(Application.restart, Array) }
       end
     end
 
@@ -25,15 +23,11 @@ module Vedeu
     end
 
     describe '#initialize' do
-      it 'returns an Application' do
-        Application.new.must_be_instance_of(Application)
-      end
+      it { return_type_for(described, Application) }
     end
 
     describe '#start' do
-      it 'returns an Array' do
-        Application.new.start.must_be_instance_of(Array)
-      end
+      it { return_type_for(described.start, Array) }
     end
 
   end # Application

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

@@ -4,15 +4,22 @@ module Vedeu
 
   describe Colour do
 
-    describe '#initialize' do
-      it 'returns an instance of itself' do
-        attributes = {}
+    let(:described)  { Colour.new(attributes) }
+    let(:attributes) {
+      {
+        background: '',
+        foreground: ''
+      }
+    }
 
-        Colour.new(attributes).must_be_instance_of(Colour)
-      end
+    describe '#initialize' do
+      it { return_type_for(described, Colour) }
+      it { assigns(described, '@attributes', attributes) }
     end
 
     describe '#background' do
+      it { return_type_for(described.background, String) }
+
       it 'returns an escape sequence' do
         Colour.new({
           background: '#000000'
@@ -25,6 +32,8 @@ module Vedeu
     end
 
     describe '#foreground' do
+      it { return_type_for(described.foreground, String) }
+
       it 'returns an escape sequence' do
         Colour.new({
           foreground: '#ff0000'
@@ -37,6 +46,8 @@ module Vedeu
     end
 
     describe '#to_s' do
+      it { return_type_for(described.to_s, String) }
+
       it 'returns an escape sequence' do
         Colour.new({
           foreground: '#ff0000',

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

@@ -4,11 +4,16 @@ module Vedeu
 
   describe Translator do
 
+    colour    = '#ff0000'
+    described = Translator.new(colour)
+
     describe '#initialize' do
       it 'returns an instance of itself' do
-        colour = ''
+        described.must_be_instance_of(Translator)
+      end
 
-        Translator.new(colour).must_be_instance_of(Translator)
+      it 'assigns the colour' do
+        assigns(described, '@colour', colour)
       end
     end
 

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

@@ -6,9 +6,18 @@ module Vedeu
 
     describe CLI do
 
+      let(:described) { CLI.new(args) }
+      let(:args)      { [] }
+
       before { Configuration.reset! }
       after  { test_configuration }
 
+      describe '#initialize' do
+        it { return_type_for(described, CLI) }
+        it { assigns(described, '@args', args) }
+        it { assigns(described, '@options', {}) }
+      end
+
       describe '#colour_mode' do
         it '--colour-mode' do
           Configuration.configure(['--colour-mode', '16777216'])

data/test/lib/vedeu/input/input_test.rb

@@ -3,15 +3,15 @@ require 'test_helper'
 module Vedeu
 
   describe Input do
-    let(:reader)   { mock }
-    let(:keypress) { 'a' }
+    let(:reader)    { mock }
+    let(:keypress)  { 'a' }
+    let(:described) { Input.new(reader) }
 
     before { reader.stubs(:read).returns(keypress) }
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Input.new(reader).must_be_instance_of(Input)
-      end
+      it { return_type_for(described, Input) }
+      it { assigns(described, '@reader', reader) }
     end
 
     describe '.capture' do

data/test/lib/vedeu/launcher_test.rb

@@ -3,6 +3,8 @@ require 'test_helper'
 module Vedeu
 
   describe Launcher do
+    let(:described) { Launcher.new }
+
     before do
       Configuration.stubs(:configure)
       Application.stubs(:start)
@@ -15,9 +17,13 @@ module Vedeu
     end
 
     describe '#initialize' do
-      it 'returns an instance of itself' do
-        Launcher.new.must_be_instance_of(Launcher)
-      end
+      it { return_type_for(described, Launcher) }
+      it { assigns(described, '@argv', []) }
+      it { assigns(described, '@stdin', STDIN) }
+      it { assigns(described, '@stdout', STDOUT) }
+      it { assigns(described, '@stderr', STDERR) }
+      it { assigns(described, '@kernel', Kernel) }
+      it { assigns(described, '@exit_code', 1) }
     end
 
     describe '#execute!' do

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

@@ -0,0 +1,197 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Border do
+
+    let(:described)  { Border.new(interface, attributes) }
+    let(:interface)  { Interface.new({
+        geometry: {
+          width:  8,
+          height: 5
+        },
+        lines: [
+          { streams: [{ text: 'Beryllium' }] },
+          { streams: [{ text: 'Magnesium' }] },
+          { streams: [{ text: 'Plutonium' }] },
+          { streams: [{ text: 'Potassium' }] },
+          { streams: [{ text: 'Lanthanum' }] },
+          { streams: [{ text: 'Stront­ium' }] },
+        ]
+      })
+    }
+    let(:attributes) { {  } }
+    let(:options)    { {  } }
+
+    describe '#initialize' do
+      it { return_type_for(described, Border) }
+      it { assigns(described, '@interface', interface) }
+      it { assigns(described, '@attributes', {
+          enabled:      false,
+          show_bottom:  true,
+          show_left:    true,
+          show_right:   true,
+          show_top:     true,
+          bottom_right: 'j',
+          top_right:    'k',
+          top_left:     'l',
+          bottom_left:  'm',
+          horizontal:   'q',
+          colour:       {},
+          style:        [],
+          vertical:     'x'
+        })
+      }
+    end
+
+    describe '#bottom?' do
+      it { return_type_for(described.bottom?, TrueClass) }
+    end
+
+    describe '#left?' do
+      it { return_type_for(described.left?, TrueClass) }
+    end
+
+    describe '#right?' do
+      it { return_type_for(described.right?, TrueClass) }
+    end
+
+    describe '#top?' do
+      it { return_type_for(described.top?, TrueClass) }
+    end
+
+    describe '#to_s' do
+      context 'when all borders should be shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled: true }).to_s.must_equal(
+            "\e(0l\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0k\e(B\n" \
+            "\e(0x\e(BBeryll\e(0x\e(B\n" \
+            "\e(0x\e(BMagnes\e(0x\e(B\n" \
+            "\e(0x\e(BPluton\e(0x\e(B\n" \
+            "\e(0m\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0j\e(B"
+          )
+        end
+      end
+
+      context 'when no borders are shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_bottom: false,
+                                  show_left:   false,
+                                  show_right:  false,
+                                  show_top:    false }).to_s.must_equal(
+            "Berylliu\n" \
+            "Magnesiu\n" \
+            "Plutoniu\n" \
+            "Potassiu\n" \
+            "Lanthanu"
+          )
+        end
+      end
+
+      context 'when the left and right border is not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_left:   false,
+                                  show_right:  false }).to_s.must_equal(
+            "\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\n" \
+            "Berylliu\n" \
+            "Magnesiu\n" \
+            "Plutoniu\n" \
+            "\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B"
+          )
+        end
+      end
+
+      context 'when the top and bottom border is not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_bottom: false,
+                                  show_top:    false }).to_s.must_equal(
+            "\e(0x\e(BBeryll\e(0x\e(B\n" \
+            "\e(0x\e(BMagnes\e(0x\e(B\n" \
+            "\e(0x\e(BPluton\e(0x\e(B\n" \
+            "\e(0x\e(BPotass\e(0x\e(B\n" \
+            "\e(0x\e(BLantha\e(0x\e(B"
+          )
+        end
+      end
+
+      context 'when the left border is shown, all others not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_bottom: false,
+                                  show_right:  false,
+                                  show_top:    false }).to_s.must_equal(
+            "\e(0x\e(BBerylli\n" \
+            "\e(0x\e(BMagnesi\n" \
+            "\e(0x\e(BPlutoni\n" \
+            "\e(0x\e(BPotassi\n" \
+            "\e(0x\e(BLanthan"
+          )
+        end
+      end
+
+      context 'when the right border is shown, all others not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_bottom: false,
+                                  show_left:   false,
+                                  show_top:    false }).to_s.must_equal(
+            "Berylli\e(0x\e(B\n" \
+            "Magnesi\e(0x\e(B\n" \
+            "Plutoni\e(0x\e(B\n" \
+            "Potassi\e(0x\e(B\n" \
+            "Lanthan\e(0x\e(B" \
+          )
+        end
+      end
+
+      context 'when the top border is shown, all others not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_bottom: false,
+                                  show_left:   false,
+                                  show_right:  false }).to_s.must_equal(
+            "\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\n" \
+            "Berylliu\n" \
+            "Magnesiu\n" \
+            "Plutoniu\n" \
+            "Potassiu"
+          )
+        end
+      end
+
+      context 'when the bottom border is shown, all others not shown' do
+        it 'returns the escape sequences to draw a border' do
+          Border.new(interface, { enabled:     true,
+                                  show_left:   false,
+                                  show_right:  false,
+                                  show_top:    false }).to_s.must_equal(
+            "Berylliu\n" \
+            "Magnesiu\n" \
+            "Plutoniu\n" \
+            "Potassiu\n" \
+            "\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B\e(0q\e(B"
+          )
+        end
+      end
+    end
+
+    describe '#to_viewport' do
+      it 'returns a value like Viewport#show but with borders' do
+        Border.new(interface, { enabled: true }).to_viewport.must_equal(
+          [
+            ["\e(0l\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0k\e(B"],
+            ["\e(0x\e(B", "B", "e", "r", "y", "l", "l", "\e(0x\e(B"],
+            ["\e(0x\e(B", "M", "a", "g", "n", "e", "s", "\e(0x\e(B"],
+            ["\e(0x\e(B", "P", "l", "u", "t", "o", "n", "\e(0x\e(B"],
+            ["\e(0m\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0q\e(B", "\e(0j\e(B"]
+          ]
+        )
+      end
+    end
+
+  end # Border
+
+end # Vedeu