vedeu 0.2.12 → 0.3.0

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

@@ -1,22 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Translator do
-
-    colour    = '#ff0000'
-    described = Translator.new(colour)
-
-    describe '#initialize' do
-      it 'returns an instance of itself' do
-        described.must_be_instance_of(Translator)
-      end
-
-      it 'assigns the colour' do
-        assigns(described, '@colour', colour)
-      end
-    end
-
-  end # Translator
-
-end # Vedeu

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

@@ -1,197 +0,0 @@
-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

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

@@ -1,52 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Char do
-
-    let(:described) { Char.new(attributes) }
-    let(:char)   { Char.new(attributes) }
-    let(:parent) {
-      {
-        colour: {
-          foreground: '#00ff00',
-          background: '#ff00ff'
-        },
-        style: []
-      }
-    }
-    let(:attributes) {
-      {
-        colour: { foreground: '#ffff00', background: '#0000ff' },
-        parent: parent,
-        style:  [],
-        value:  value,
-      }
-    }
-    let(:value)   { 'a' }
-
-    describe '#initialize' do
-      it { return_type_for(described, Char) }
-      it { assigns(described, '@attributes', attributes) }
-      it { assigns(described, '@parent', parent) }
-      it { assigns(described, '@value', value) }
-    end
-
-    describe '#to_s' do
-      it { return_type_for(described.to_s, String) }
-
-      it 'returns the escape sequences and content' do
-        # - char colours and style as set in Stream#chars.
-        # - the value.
-        # - the colours and style of the line which the Char belongs to.
-        char.to_s.must_equal(
-          "\e[38;2;255;255;0m\e[48;2;0;0;255m" \
-          "a" \
-          "\e[38;2;0;255;0m\e[48;2;255;0;255m"
-        )
-      end
-    end
-
-  end # Char
-
-end # Vedeu

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

@@ -1,45 +0,0 @@
-require 'test_helper'
-
-require 'json'
-
-module Vedeu
-
-  describe Composition do
-    let(:described)  { Composition.new(attributes) }
-    let(:attributes) { {} }
-
-    before { Buffers.reset }
-
-    describe '#initialize' do
-      it { return_type_for(described, Composition) }
-      it { assigns(described, '@attributes', { interfaces: [] }) }
-    end
-
-    describe '#interfaces' do
-      it 'returns a collection of interfaces' do
-        Vedeu.interface('dummy') do
-          width  5
-          height 5
-        end
-        Composition.new({
-          interfaces: {
-            name:  'dummy',
-            lines: []
-          }
-        }).interfaces.first.must_be_instance_of(Interface)
-      end
-
-      it 'returns an empty collection when no interfaces are associated' do
-        described.interfaces.must_be_empty
-      end
-    end
-
-    describe '#method_missing' do
-      it 'returns nil' do
-        described.some_missing_method(:test).must_equal(nil)
-      end
-    end
-
-  end # Composition
-
-end # Vedeu

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

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Key do
-
-    let(:described) { Key.new(input, output) }
-    let(:input)     { '' }
-    let(:output)    { Proc.new { :output } }
-
-    describe '#initialize' do
-      it { return_type_for(described, Key) }
-      it { assigns(described, '@input', input) }
-
-      it { skip; assigns(described, '@output', output) }
-    end
-
-    describe '#input' do
-      it 'returns the key defined' do
-        Key.new('a', output).input.must_equal('a')
-      end
-
-      context 'alias method #key' do
-        it { Key.new('a', output).key.must_equal('a') }
-      end
-    end
-
-    describe '#output' do
-    end
-
-    describe '#press' do
-      it 'returns the result of calling the proc' do
-        Key.new(input, output).press.must_equal(:output)
-      end
-
-      it 'returns a :noop when the output is not a proc' do
-        Key.new(input, :output).press.must_equal(:noop)
-      end
-    end
-
-  end # Key
-
-end # Vedeu

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

@@ -1,123 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Line do
-
-    let(:described)  { Line.new(attributes) }
-    let(:line)       { Line.new(attributes) }
-    let(:attributes) {
-      {
-        colour: {
-          foreground: '#ff0000',
-          background: '#000000'
-        },
-        streams: streams,
-        style:   'normal',
-        parent:  nil,
-      }
-    }
-    let(:streams) {
-      [
-        Stream.new({
-          colour: { foreground: '#ff0000' }, text: 'Something interesting ' }),
-        Stream.new({
-          colour: { foreground: '#00ff00' }, text: 'on this line ' }),
-        Stream.new({
-          colour: { foreground: '#0000ff' }, text: 'would be cool, eh?' })
-      ]
-    }
-
-    describe '#initialize' do
-      it { return_type_for(described, Line) }
-      it { assigns(described, '@attributes', attributes) }
-      it { assigns(described, '@parent', nil) }
-    end
-
-    describe '#attributes' do
-      it 'returns the attributes' do
-        described.attributes.must_equal(attributes)
-      end
-    end
-
-    describe '#chars' do
-      it { return_type_for(described.chars, Array) }
-
-      context 'when there is no content' do
-        before { described.stubs(:size).returns(0) }
-
-        it { described.chars.must_equal([]) }
-      end
-
-      context 'when there is content' do
-        it 'returns an Array' do
-          described.chars.must_equal(
-            [
-              "\e[38;2;255;0;0mS", "\e[38;2;255;0;0mo", "\e[38;2;255;0;0mm",
-              "\e[38;2;255;0;0me", "\e[38;2;255;0;0mt", "\e[38;2;255;0;0mh",
-              "\e[38;2;255;0;0mi", "\e[38;2;255;0;0mn", "\e[38;2;255;0;0mg",
-              "\e[38;2;255;0;0m ", "\e[38;2;255;0;0mi", "\e[38;2;255;0;0mn",
-              "\e[38;2;255;0;0mt", "\e[38;2;255;0;0me", "\e[38;2;255;0;0mr",
-              "\e[38;2;255;0;0me", "\e[38;2;255;0;0ms", "\e[38;2;255;0;0mt",
-              "\e[38;2;255;0;0mi", "\e[38;2;255;0;0mn", "\e[38;2;255;0;0mg",
-              "\e[38;2;255;0;0m ", "\e[38;2;0;255;0mo", "\e[38;2;0;255;0mn",
-              "\e[38;2;0;255;0m ", "\e[38;2;0;255;0mt", "\e[38;2;0;255;0mh",
-              "\e[38;2;0;255;0mi", "\e[38;2;0;255;0ms", "\e[38;2;0;255;0m ",
-              "\e[38;2;0;255;0ml", "\e[38;2;0;255;0mi", "\e[38;2;0;255;0mn",
-              "\e[38;2;0;255;0me", "\e[38;2;0;255;0m ", "\e[38;2;0;0;255mw",
-              "\e[38;2;0;0;255mo", "\e[38;2;0;0;255mu", "\e[38;2;0;0;255ml",
-              "\e[38;2;0;0;255md", "\e[38;2;0;0;255m ", "\e[38;2;0;0;255mb",
-              "\e[38;2;0;0;255me", "\e[38;2;0;0;255m ", "\e[38;2;0;0;255mc",
-              "\e[38;2;0;0;255mo", "\e[38;2;0;0;255mo", "\e[38;2;0;0;255ml",
-              "\e[38;2;0;0;255m,", "\e[38;2;0;0;255m ", "\e[38;2;0;0;255me",
-              "\e[38;2;0;0;255mh", "\e[38;2;0;0;255m?"
-            ]
-          )
-        end
-      end
-    end
-
-    describe '#empty?' do
-      context 'when there is no content' do
-        before { line.stubs(:size).returns(0) }
-
-        it { line.empty?.must_equal(true) }
-      end
-
-      it 'returns false when there is content' do
-        line.empty?.must_equal(false)
-      end
-    end
-
-    describe '#size' do
-      it { return_type_for(described.size, Fixnum) }
-
-      it 'returns the size of the line' do
-        line.size.must_equal(53)
-      end
-    end
-
-    describe '#streams' do
-      it { return_type_for(described.streams, Array) }
-    end
-
-    describe '#to_s' do
-      it 'returns a String' do
-        line.to_s.must_equal(
-          "\e[38;2;255;0;0m\e[48;2;0;0;0m" \
-          "\e[24m\e[22m\e[27m\e[38;2;255;0;0mSomething interesting "\
-          "\e[38;2;0;255;0mon this line " \
-          "\e[38;2;0;0;255mwould be cool, eh?"
-        )
-      end
-    end
-
-    describe '#method_missing' do
-      it 'returns nil' do
-        Line.new.some_missing_method(:test).must_equal(nil)
-      end
-    end
-
-  end # Line
-
-end # Vedeu