vedeu 0.2.12 → 0.3.0

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

@@ -0,0 +1,288 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Menu do
+
+    let(:described)  { Vedeu::Menu }
+    let(:instance)   { described.new(collection, menu_name, current, selected) }
+    let(:collection) { ['hydrogen', 'carbon', 'nitrogen', 'oxygen'] }
+    let(:menu_name)  { 'elements' }
+    let(:current)    { 0 }
+    let(:selected)   {}
+
+    before { Vedeu.menus.reset }
+
+    describe '.build' do
+      subject { described.build }
+
+      it { subject.must_be_instance_of(described) }
+    end
+
+    describe '.menu' do
+      subject {
+        described.menu('elements') do
+          # ...
+        end
+      }
+
+      it { subject.must_be_instance_of(described) }
+
+      context 'when the block is not given' do
+        subject { described.menu }
+
+        it { proc { subject }.must_raise(InvalidSyntax) }
+      end
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+
+      it { subject.instance_variable_get('@collection').must_equal(collection) }
+      it { subject.instance_variable_get('@name').must_equal('elements') }
+      it { subject.instance_variable_get('@current').must_equal(0) }
+      it { subject.instance_variable_get('@selected').must_equal(nil) }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.menus) }
+    end
+
+    describe '#current' do
+      subject { instance.current }
+
+      it 'returns the current index' do
+        subject.must_equal(0)
+      end
+    end
+
+    describe '#selected' do
+      subject { instance.selected }
+
+      it 'returns nil when no item is selected' do
+        subject.must_equal(nil)
+      end
+
+      it 'returns the selected index when an item is selected' do
+        instance.next_item
+        instance.select_item
+
+        subject.must_equal(1)
+      end
+    end
+
+    describe '#current_item' do
+      subject { instance.current_item }
+
+      it 'returns the current item from the collection' do
+        subject.must_equal('hydrogen')
+      end
+
+      it 'when the current item has changed' do
+        instance.next_item
+        instance.next_item
+
+        subject.must_equal('nitrogen')
+      end
+    end
+
+    describe '#selected_item' do
+      subject { instance.selected_item }
+
+      it 'returns nil when nothing is selected' do
+        subject.must_equal(nil)
+      end
+
+      it 'returns the selected item from the collection' do
+        instance.next_item
+        instance.select_item
+
+        subject.must_equal('carbon')
+      end
+    end
+
+    describe '#items' do
+      it 'returns a collection of items' do
+        instance.items.must_equal(
+          [
+            [false, true,  'hydrogen'],
+            [false, false, 'carbon'],
+            [false, false, 'nitrogen'],
+            [false, false, 'oxygen']
+          ]
+        )
+      end
+
+      it 'returns a collection of items when the current has ' \
+         'changed' do
+        instance.next_item
+        instance.items.must_equal(
+          [
+            [false, false, 'hydrogen'],
+            [false, true,  'carbon'],
+            [false, false, 'nitrogen'],
+            [false, false, 'oxygen']
+          ]
+        )
+      end
+
+      it 'returns a collection of items when an item is selected' do
+        instance.next_item
+        instance.select_item
+        instance.items.must_equal(
+          [
+            [false, false, 'hydrogen'],
+            [true,  true,  'carbon'],
+            [false, false, 'nitrogen'],
+            [false, false, 'oxygen']
+          ]
+        )
+      end
+
+      it 'returns a collection of items when the current has ' \
+         'changed and an item is selected' do
+        instance.next_item
+        instance.select_item
+        instance.next_item
+        instance.next_item
+        instance.items.must_equal(
+          [
+            [false, false, 'hydrogen'],
+            [true,  false, 'carbon'],
+            [false, false, 'nitrogen'],
+            [false, true,  'oxygen']
+          ]
+        )
+      end
+    end
+
+    describe '#view' do
+      it 'returns a collection of items when the start position ' \
+         'has changed' do
+        instance.top_item
+        instance.next_item
+        instance.view.must_equal(
+          [
+            [false, true, 'carbon'],
+            [false, false, 'nitrogen'],
+            [false, false, 'oxygen']
+          ]
+        )
+      end
+    end
+
+    describe '#top_item' do
+      it 'sets current to the index of the first item' do
+        instance.next_item
+        instance.top_item
+        instance.current.must_equal(0)
+      end
+
+      it 'returns the items' do
+        instance.top_item.must_equal(instance.items)
+      end
+    end
+
+    describe '#bottom_item' do
+      it 'sets current to the index of the last item' do
+        instance.bottom_item
+        instance.current.must_equal(3)
+      end
+
+      it 'returns the items' do
+        instance.bottom_item.must_equal(instance.items)
+      end
+    end
+
+    describe '#next_item' do
+      it 'sets the current to the index of the next item' do
+        instance.next_item
+        instance.current.must_equal(1)
+      end
+
+      it 'returns the items' do
+        instance.next_item.must_equal(instance.items)
+      end
+
+      it 'does not loop' do
+        instance.next_item
+        instance.next_item
+        instance.next_item
+        instance.next_item
+        instance.next_item
+        instance.current.must_equal(3)
+      end
+    end
+
+    describe '#prev_item' do
+      it 'does not loop' do
+        instance.prev_item
+        instance.current.must_equal(0)
+      end
+
+      it 'sets the current to the index of the previous item' do
+        instance.next_item
+        instance.next_item
+        instance.prev_item
+        instance.current.must_equal(1)
+      end
+
+      it 'returns the items' do
+        instance.prev_item.must_equal(instance.items)
+      end
+
+      it 'does not loop' do
+        instance.next_item
+        instance.next_item
+        instance.next_item
+        instance.prev_item
+        instance.prev_item
+        instance.current.must_equal(1)
+      end
+    end
+
+    describe '#select_item' do
+      it 'sets the selected index to the current index' do
+        instance.select_item
+        instance.selected.must_equal(0)
+      end
+
+      it 'sets the selected index to the current index' do
+        instance.next_item
+        instance.select_item
+        instance.selected.must_equal(1)
+      end
+
+      it 'returns the items' do
+        instance.select_item.must_equal(instance.items)
+      end
+    end
+
+    describe '#deselect_item' do
+      it 'sets the selected index to nil' do
+        instance.next_item
+        instance.next_item
+        instance.select_item
+        instance.deselect_item
+        instance.selected.must_equal(nil)
+      end
+
+      it 'returns the items' do
+        instance.deselect_item.must_equal(instance.items)
+      end
+    end
+
+    describe '#last' do
+      it 'returns the index of the last item' do
+        instance.last.must_equal(3)
+      end
+    end
+
+    describe '#size' do
+      it 'returns the collection size' do
+        instance.size.must_equal(4)
+      end
+    end
+
+  end # Menu
+
+end # Vedeu

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

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Model do
+    let(:model_instance) { ModelTestClass.new(attributes) }
+    let(:attributes) {
+      {
+        name: 'hydrogen'
+      }
+    }
+
+    describe '#deputy' do
+      subject { model_instance.deputy }
+
+      it 'returns the DSL instance' do
+        subject.must_be_instance_of(DSL::ModelTestClass)
+      end
+    end
+
+    describe '#store' do
+      subject { model_instance.store }
+
+      it 'returns the model' do
+        subject.must_be_instance_of(ModelTestClass)
+      end
+    end
+
+  end # Model
+
+end # Vedeu

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

@@ -0,0 +1,166 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Char do
+
+    let(:described)     { Vedeu::Char }
+    let(:instance)      { described.new(value, parent, colour, style, position) }
+    let(:value)         { 'a' }
+    let(:parent)        { Line.new([], nil, parent_colour, parent_style) }
+    let(:colour)        { nil }
+    let(:style)         { nil }
+    let(:position)      { nil }
+    let(:parent_colour) { nil }
+    let(:parent_style)  { nil }
+
+    describe '.coerce' do
+      subject { described.coerce(value, parent, colour, style, position) }
+
+      context 'when the value is already a Char' do
+        let(:value) { described.new('b') }
+
+        it { subject.must_equal(value) }
+      end
+
+      context 'when the value is an Array' do
+        context 'and the Array contains instances of Char' do
+          let(:value) { [described.new('b')] }
+
+          it { subject.must_equal(value) }
+        end
+
+        context 'and the Array contains instances of String' do
+          let(:value) { ['carbon'] }
+
+          it { subject.must_be_instance_of(Array) }
+        end
+
+        context 'and the Array contains instances of NilClass' do
+          let(:value) { [] }
+
+          it { subject.must_be_instance_of(NilClass) }
+        end
+      end
+
+      context 'when the value is not a Char or Array' do
+        let(:value) { {} }
+
+        it { subject.must_be_instance_of(NilClass) }
+      end
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Char) }
+      it { subject.instance_variable_get('@colour').must_equal(colour) }
+      it { subject.instance_variable_get('@parent').must_equal(parent) }
+      it { subject.instance_variable_get('@style').must_equal(style) }
+      it { subject.instance_variable_get('@value').must_equal(value) }
+      it { subject.instance_variable_get('@position').must_equal(position) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Char (value:a)>') }
+    end
+
+    describe '#value' do
+      subject { instance.value }
+
+      context 'when the value is not set' do
+        let(:value) {}
+
+        it { subject.must_equal('') }
+      end
+
+      context 'when the value is set' do
+        it { subject.must_equal('a') }
+
+        context 'and the value is more than one character' do
+          let(:value) { 'multi' }
+
+          it { subject.must_equal('m') }
+        end
+      end
+    end
+
+    describe '#to_s' do
+      subject { instance.to_s }
+
+      it { subject.must_be_instance_of(String) }
+
+      context 'when a position is specified' do
+        let(:position) { Position.new(17, 2) }
+
+        it { subject.must_equal("\e[17;2Ha\e[17;2H") }
+      end
+
+      context 'when a position is not specified' do
+        let(:position) {}
+
+        it { subject.must_equal("a") }
+      end
+
+      context 'when a colour is specified' do
+        let(:colour) { Colour.new({ foreground: '#00ff00', background: '#005500' }) }
+
+        context 'when a parent colour is specified' do
+          let(:parent_colour) { Colour.new({ foreground: '#ff0000', background: '#550000' }) }
+
+          it { subject.must_equal("\e[38;2;0;255;0m\e[48;2;0;85;0ma\e[38;2;255;0;0m\e[48;2;85;0;0m") }
+        end
+
+        context 'when a parent colour is not specified' do
+          let(:parent_colour) {}
+
+          it { subject.must_equal("\e[38;2;0;255;0m\e[48;2;0;85;0ma") }
+        end
+      end
+
+      context 'when a colour is not specified' do
+        let(:colour) {}
+
+        it { subject.must_equal("a") }
+      end
+
+      context 'when a style is specified' do
+        let(:style) { Style.new('underline') }
+
+        context 'when a parent style is specified' do
+          let(:parent_style) { Style.new('bold') }
+
+          it { subject.must_equal("\e[4ma\e[1m") }
+        end
+
+        context 'when a parent style is not specified' do
+          let(:parent_style) {}
+
+          it { subject.must_equal("\e[4ma") }
+        end
+      end
+
+      context 'when a style is not specified' do
+        let(:style) {}
+
+        it { subject.must_equal("a") }
+      end
+
+      context 'when the value is nil' do
+        let(:value) {}
+
+        it { subject.must_equal("") }
+      end
+
+      context 'when the value is more than one character' do
+        let(:value) { 'multi' }
+
+        it { subject.must_equal("m") }
+      end
+    end
+
+  end # Char
+
+end # Vedeu

data/test/lib/vedeu/models/view/chars_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Chars do
+
+    let(:described) { Vedeu::Chars }
+    let(:instance)  { described.new }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Vedeu::Chars) }
+    end
+
+  end # Chars
+
+end # Vedeu

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

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Composition do
+
+    let(:described) { Vedeu::Composition }
+    let(:instance)  { described.new(interfaces) }
+
+    let(:interfaces) { [] }
+    let(:colour)     {}
+    let(:style)      {}
+
+    describe '.build' do
+      subject {
+        described.build({}) do
+          # ...
+        end
+      }
+
+      it { subject.must_be_instance_of(Composition) }
+    end
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(described) }
+      it { subject.instance_variable_get('@interfaces').must_equal(interfaces) }
+      it { subject.instance_variable_get('@colour').must_equal(colour) }
+      it { subject.instance_variable_get('@style').must_equal(style) }
+    end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Composition (interfaces:0)>') }
+    end
+
+  end # Composition
+
+end # Vedeu

data/test/lib/vedeu/models/view/interface_test.rb

@@ -0,0 +1,128 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Interface do
+
+    let(:described) { Vedeu::Interface }
+    let(:instance)  { described.new(_name, lines, parent, colour, style) }
+    let(:_name)     { 'hydrogen' }
+    let(:lines)     { [] }
+    let(:parent)    {}
+    let(:colour)    {}
+    let(:style)     {}
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.instance_variable_get('@name').must_equal(_name) }
+      it { subject.instance_variable_get('@lines').must_equal(lines) }
+      it { subject.instance_variable_get('@parent').must_equal(parent) }
+      it { subject.instance_variable_get('@colour').must_equal(colour) }
+      it { subject.instance_variable_get('@style').must_equal(style) }
+      it { subject.instance_variable_get('@border').must_equal(nil) }
+      it { subject.instance_variable_get('@delay').must_equal(0.0) }
+      it { subject.instance_variable_get('@geometry').must_equal(nil) }
+      it { subject.instance_variable_get('@group').must_equal('') }
+      it { subject.instance_variable_get('@repository').must_equal(Vedeu.interfaces) }
+    end
+
+    describe '#border?' do
+      subject { instance.border? }
+
+      context 'when the interface has a border' do
+        before { instance.stubs(:border).returns(mock('Border')) }
+
+        it { subject.must_equal(true) }
+      end
+
+      context 'when the interface does not have a border' do
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#lines?' do
+      subject { instance.lines? }
+
+      context 'when the interface has content' do
+        let(:lines) { [:line] }
+
+        it { subject.must_equal(true) }
+      end
+
+      context 'when the interface does not have content' do
+        it { subject.must_equal(false) }
+      end
+    end
+
+    describe '#cursor' do
+      subject { instance.cursor }
+
+      it { subject.must_be_instance_of(Vedeu::Cursor) }
+    end
+
+    # TODO: when the interface does not have any geometry defined?
+    # describe '#render' do
+    #   subject { instance.render }
+
+    #   context 'when the interface has a border' do
+    #     let(:border) { Vedeu::Border.new(instance, { enabled: true }) }
+
+    #     before { instance.stubs(:border).returns(border) }
+
+    #     it { skip }
+    #   end
+
+    #   context 'when the interface does not have a border' do
+    #     it { skip }
+    #   end
+    # end
+
+    describe '#inspect' do
+      subject { instance.inspect }
+
+      it { subject.must_equal('<Vedeu::Interface (lines:0)>') }
+    end
+
+    describe '#store' do
+      subject { instance.store }
+
+      context 'when the interface has no name' do
+        let(:_name) {}
+
+        it { proc { subject }.must_raise(MissingRequired) }
+      end
+
+      # context 'when the interface has a name' do
+      #   context 'when a buffer exists' do
+      #     it { skip }
+      #   end
+
+      #   context 'when a buffer does not exist' do
+      #     it { skip }
+      #   end
+
+      #   context 'when a refresh event exists' do
+      #     it { skip }
+      #   end
+
+      #   context 'when a refresh event does not exist' do
+      #     it { skip }
+      #   end
+
+      #   context 'when the interface has a group' do
+      #     it { skip }
+      #   end
+      # end
+    end
+
+    # TODO: when the interface does not have any geometry defined?
+    describe '#viewport' do
+      subject { instance.viewport }
+
+      # it { skip }
+    end
+
+  end # Interface
+
+end # Vedeu

data/test/lib/vedeu/models/view/interfaces_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module Vedeu
+
+  describe Interfaces do
+
+    let(:described) { Vedeu::Interfaces }
+    let(:instance)  { described.new }
+
+    describe '#initialize' do
+      subject { instance }
+
+      it { subject.must_be_instance_of(Vedeu::Interfaces) }
+    end
+
+  end # Interfaces
+
+end # Vedeu