vedeu 0.2.12 → 0.3.0

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

@@ -0,0 +1,357 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Border do
+
+    let(:described)  { Vedeu::Border }
+    let(:instance)   { described.new(interface, attributes) }
+    # let(:interface)  { Interface.new({ name: 'caesium' }) }
+    let(:interface)  {
+      Vedeu::Interface.build do
+        geometry do
+          height 5
+          width  8
+        end
+        name 'caesium'
+      end
+    }
+    let(:attributes) { {} }
+
+    before do
+      interface.lines = [
+        Line.new([Stream.new('Beryllium')]),
+        Line.new([Stream.new('Magnesium')]),
+        Line.new([Stream.new('Plutonium')]),
+        Line.new([Stream.new('Potassium')]),
+        Line.new([Stream.new('Lanthanum')]),
+        Line.new([Stream.new('Stront­ium')])
+      ]
+    end
+
+    describe '.build' do
+      subject {
+        described.build(attributes) do
+          horizontal '~'
+        end
+      }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Border) }
+      it { subject.instance_variable_get('@interface').must_equal(interface) }
+      it { subject.instance_variable_get('@attributes').must_equal(
+        {
+          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',
+          interface:    nil,
+        })
+      }
+    end
+
+    describe '#width' do
+      subject { instance.width }
+
+      context 'when the border is not enabled' do
+        it 'returns the interface width' do
+          subject.must_equal(8)
+        end
+      end
+
+      context 'when the border is enabled' do
+        context 'when both left and right borders are shown' do
+          let(:attributes) { { enabled: true } }
+
+          it { subject.must_equal(6) }
+        end
+
+        context 'when either the left or right border is shown' do
+          let(:attributes) { { enabled: true, show_left: false } }
+
+          it { subject.must_equal(7) }
+        end
+
+        context 'when neither left nor right borders are shown' do
+          let(:attributes) { { enabled: true, show_left: false, show_right: false } }
+
+          it { subject.must_equal(8) }
+        end
+      end
+    end
+
+    describe '#height' do
+      subject { instance.height }
+
+      context 'when the border is not enabled' do
+        it 'returns the interface height' do
+          subject.must_equal(5)
+        end
+      end
+
+      context 'when the border is enabled' do
+        context 'when both top and bottom borders are shown' do
+          let(:attributes) { { enabled: true } }
+
+          it { subject.must_equal(3) }
+        end
+
+        context 'when either the top or bottom border is shown' do
+          let(:attributes) { { enabled: true, show_top: false } }
+
+          it { subject.must_equal(4) }
+        end
+
+        context 'when neither top nor bottom borders are shown' do
+          let(:attributes) { { enabled: true, show_top: false, show_bottom: false } }
+
+          it { subject.must_equal(5) }
+        end
+      end
+    end
+
+    describe '#colour=' do
+      let(:value) { { foreground: '#00ff00' } }
+
+      subject { instance.colour=(value) }
+
+      it { subject; instance.instance_variable_get("@colour").must_be_instance_of(Colour) }
+    end
+
+    describe '#style=' do
+      let(:value) { 'normal' }
+
+      subject { instance.style=(value) }
+
+      it { subject; instance.instance_variable_get("@style").must_be_instance_of(Style) }
+    end
+
+    describe '#enabled?' do
+      subject { instance.enabled? }
+
+      it { subject.must_be_instance_of(FalseClass) }
+
+      context 'when true' do
+        let(:attributes) { { enabled: true } }
+
+        it { subject.must_be_instance_of(TrueClass) }
+      end
+    end
+
+    describe '#bottom?' do
+      subject { instance.bottom? }
+
+      it { subject.must_be_instance_of(TrueClass) }
+
+      context 'when false' do
+        let(:attributes) { { show_bottom: false } }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#left?' do
+      subject { instance.left? }
+
+      it { subject.must_be_instance_of(TrueClass) }
+
+      context 'when false' do
+        let(:attributes) { { show_left: false } }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#right?' do
+      subject { instance.right? }
+
+      it { subject.must_be_instance_of(TrueClass) }
+
+      context 'when false' do
+        let(:attributes) { { show_right: false } }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#top?' do
+      subject { instance.top? }
+
+      it { subject.must_be_instance_of(TrueClass) }
+
+      context 'when false' do
+        let(:attributes) { { show_top: false } }
+
+        it { subject.must_be_instance_of(FalseClass) }
+      end
+    end
+
+    describe '#to_s' do
+      subject { instance.to_s }
+
+      context 'when all borders should be shown' do
+        let(:attributes) {
+          { enabled: true }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_bottom: false,
+            show_left:   false,
+            show_right:  false,
+            show_top:    false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.must_equal(
+            "Berylliu\n" \
+            "Magnesiu\n" \
+            "Plutoniu\n" \
+            "Potassiu\n" \
+            "Lanthanu"
+          )
+        end
+      end
+
+      context 'when the left and right border is not shown' do
+        let(:attributes) {
+          { enabled:     true,
+            show_left:   false,
+            show_right:  false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_bottom: false,
+            show_top:    false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_bottom: false,
+            show_right:  false,
+            show_top:    false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_bottom: false,
+            show_left:   false,
+            show_top:    false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_bottom: false,
+            show_left:   false,
+            show_right:  false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+        let(:attributes) {
+          { enabled:     true,
+            show_left:   false,
+            show_right:  false,
+            show_top:    false }
+        }
+
+        it 'returns the escape sequences to draw a border' do
+          subject.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
+
+  end # Border
+
+end # Vedeu

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

@@ -2,32 +2,78 @@ require 'test_helper'
 
 module Vedeu
 
+  # TODO: Leak detected. (GL 2015-01-28)
+
   describe Compositor do
 
-    let(:described) { Compositor.new(interface, buffer) }
+    let(:described) { Vedeu::Compositor }
+    let(:instance)  { described.new(_name) }
+    let(:_name)     { 'compositor' }
+    let(:buffer)    { Buffer.new(_name, interface) }
     let(:interface) {
-      {
-        name: 'indium'
-      }
-    }
-    let(:buffer) {
-      Buffer.new({ name: 'indium' })
+      Vedeu.interface(_name) do
+        geometry do
+          height 5
+          width  10
+        end
+        lines do
+          line 'Some text.'
+        end
+      end
     }
 
     before do
-      Focus.stubs(:cursor).returns("\e[?25l")
-      Terminal.console.stubs(:print)
+      IO.console.stubs(:print)
+
+      Vedeu.buffers.reset
+      Vedeu.interfaces.reset
+      Buffer.new(_name, interface).store
     end
 
     describe '#initialize' do
-      it { return_type_for(described, Compositor) }
-      it { assigns(described, '@interface', interface) }
-      it { assigns(described, '@buffer', buffer) }
+      subject { instance }
+
+      it { subject.must_be_instance_of(Compositor) }
+      it { subject.instance_variable_get('@name').must_equal(_name) }
     end
 
-    describe '#compose' do
-      it { return_type_for(described.compose, Array) }
-      it { return_value_for(described.compose, [{}]) }
+    describe '.compose' do
+      subject { described.compose(_name) }
+
+      # it { skip }
+
+      context 'when there is no content' do
+        # it { skip }
+      end
+
+      context 'when there is content' do
+        context 'when the view has redefined the geometry' do
+          # it { skip }
+        end
+
+        context 'when the view has not redefined the geometry' do
+          it 'returns the escape sequences and content sent to the console' do
+            subject.must_equal(
+              [
+                [
+                  "\e[1;1H          \e[1;1H" \
+                  "\e[2;1H          \e[2;1H" \
+                  "\e[3;1H          \e[3;1H" \
+                  "\e[4;1H          \e[4;1H" \
+                  "\e[5;1H          \e[5;1H" \
+                  "\e[1;1HSome text." \
+                  "\e[2;1H          " \
+                  "\e[3;1H          " \
+                  "\e[4;1H          " \
+                  "\e[5;1H          ",
+
+                  "\e[1;1H\e[?25l"
+                ]
+              ]
+            )
+          end
+        end
+      end
     end
 
   end # Compositor

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

@@ -6,103 +6,44 @@ module Vedeu
 
     let(:described) { Output.new(interface) }
     let(:interface) {
-      Interface.new({
-        name:   'flourine',
-        geometry: {
-          width:  32,
-          height: 3,
-        },
-        lines:    lines,
-        colour:   colour
-      })
+      Interface.build do
+        geometry do
+          height 3
+          width  32
+        end
+        name 'flourine'
+      end
     }
     let(:lines) {
       [
-        {
-          streams: [{ text: 'this is the first' }]
-        },
-        {
-          streams: [{ text: 'this is the second and it is long' }]
-        },
-        {
-          streams: [{ text: 'this is the third, it is even longer and still truncated' }]
-        },
-        {
-          streams: [{ text: 'this should not render' }]
-        }
+        Line.new([Stream.new('this is the first')]),
+        Line.new([Stream.new('this is the second and it is long')]),
+        Line.new([Stream.new('this is the third, it is even longer and still truncated')]),
+        Line.new([Stream.new('this should not render')]),
       ]
     }
-    let(:colour) { {} }
 
-    # before do
-    #   Buffers.reset
-    #   Cursors.reset
-    #   Interfaces.reset
-
-    #   Terminal.console.stubs(:winsize).returns([5, 40])
-    #   Terminal.console.stubs(:print)
-    # end
+    before do
+      interface.lines = lines
+      IO.console.stubs(:print)
+    end
 
     describe '#initialize' do
-      it { return_type_for(described, Output) }
-      it { assigns(described, '@interface', interface) }
+      it { described.must_be_instance_of(Output) }
+      it { described.instance_variable_get('@interface').must_equal(interface) }
     end
 
-    # describe '.render' do
-    #   it 'returns the content for the interface' do
-    #     Output.render(interface).must_equal(
-    #       "\e[1;1H                                \e[1;1H" \
-    #       "\e[2;1H                                \e[2;1H" \
-    #       "\e[3;1H                                \e[3;1H" \
-    #       "\e[1;1Hthis is the first" \
-    #       "\e[2;1Hthis is the second and it is lon" \
-    #       "\e[3;1Hthis is the third, it is even lo"
-    #     )
-    #   end
+    describe '.render' do
+      subject { Output.render(interface) }
 
-    #   context 'when there are no streams of text' do
-    #     let(:lines) { [] }
+      it { subject.must_be_instance_of(Array) }
 
-    #     it 'returns a blank interface' do
-    #       Output.render(interface).must_equal(
-    #         "\e[1;1H                                \e[1;1H" \
-    #         "\e[2;1H                                \e[2;1H" \
-    #         "\e[3;1H                                \e[3;1H"
-    #       )
-    #     end
-    #   end
+      context 'when a border is defined for the interface' do
+      end
 
-    #   context 'when lines have streams which are empty' do
-    #     let(:lines) {
-    #       [
-    #         {
-    #           streams: [{ text: 'this is the first' }]
-    #         }, {
-    #           streams: { text: '' }
-    #         }, {
-    #           streams: [
-    #             { text: 'this is the third, ' },
-    #             { text: 'it is even longer '  },
-    #             { text: 'and still truncated' }
-    #           ]
-    #         }, {
-    #           streams: [{ text: 'this should not render' }]
-    #         }
-    #       ]
-    #     }
-
-    #     it 'skips lines' do
-    #       Output.render(interface).must_equal(
-    #         "\e[1;1H                                \e[1;1H" \
-    #         "\e[2;1H                                \e[2;1H" \
-    #         "\e[3;1H                                \e[3;1H" \
-    #         "\e[1;1Hthis is the first" \
-    #         "\e[2;1H" \
-    #         "\e[3;1Hthis is the third, it is even lo"
-    #       )
-    #     end
-    #   end
-    # end
+      context 'when a border is not defined for the interface' do
+      end
+    end
 
   end # Output