vedeu 0.2.12 → 0.3.0

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

@@ -1,130 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Interface do
-    let(:described)  { Interface.new(attributes) }
-    let(:attributes) { {} }
-
-    let(:interface) { Vedeu.use('#initialize') }
-
-    before do
-      Interfaces.reset
-      Vedeu.interface('#initialize') do
-        group 'my_group'
-        colour foreground: '#ff0000', background: '#000000'
-        y 3
-        x 5
-        width 10
-        height 15
-      end
-    end
-
-    describe '#initialize' do
-      it { return_type_for(described, Interface) }
-      it { assigns(described, '@attributes', {
-          border:   {},
-          colour:   {},
-          cursor:   :hide,
-          delay:    0.0,
-          geometry: {},
-          group:    '',
-          lines:    [],
-          name:     '',
-          parent:   nil,
-          style:    ''
-        })
-      }
-      it { assigns(described, '@cursor', :hide) }
-      it { assigns(described, '@delay', 0.0) }
-      it { assigns(described, '@group', '') }
-      it { assigns(described, '@name', '') }
-      it { assigns(described, '@parent', nil) }
-    end
-
-    describe '#attributes' do
-      it 'returns the value' do
-        interface.attributes.must_equal(
-          {
-            border: {},
-            colour: {
-              foreground: '#ff0000',
-              background: '#000000'
-            },
-            cursor: :hide,
-            delay: 0.0,
-            geometry: {
-              y: 3,
-              x: 5,
-              width: 10,
-              height: 15,
-            },
-            group: 'my_group',
-            lines: [],
-            name: '#initialize',
-            parent: nil,
-            style: '',
-          }
-        )
-      end
-    end
-
-    describe '#border' do
-      it { return_type_for(described.border, Border) }
-    end
-
-    describe '#cursor' do
-      it { return_type_for(described.cursor, Cursor) }
-    end
-
-    describe '#name' do
-      it 'returns the value' do
-        interface.name.must_equal('#initialize')
-      end
-    end
-
-    describe '#in_focus?' do
-      context 'when the interface is currently in focus' do
-        before { Focus.stubs(:current?).returns(true) }
-
-        it { interface.in_focus?.must_equal(true) }
-      end
-
-      context 'when the interface is not currently in focus' do
-        before { Focus.stubs(:current?).returns(false) }
-
-        it { interface.in_focus?.must_equal(false) }
-      end
-    end
-
-    describe '#group' do
-      it 'returns the value' do
-        interface.group.must_equal('my_group')
-      end
-    end
-
-    describe '#lines' do
-      it 'returns the value' do
-        interface.lines.must_equal([])
-      end
-    end
-
-    describe '#geometry' do
-      it { return_type_for(described.geometry, Geometry) }
-    end
-
-    describe '#delay' do
-      it 'returns the value' do
-        interface.delay.must_equal(0.0)
-      end
-    end
-
-    describe '#method_missing' do
-      it 'returns nil' do
-        interface.some_missing_method(:test).must_equal(nil)
-      end
-    end
-
-  end # Interface
-
-end # Vedeu

data/test/lib/vedeu/repositories/models/keymap_test.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Keymap do
-
-    let(:described)  { Keymap.new(attributes) }
-    let(:attributes) { {} }
-
-    describe '.define' do
-      it { return_type_for(Keymap.define, Keymap) }
-    end
-
-    describe '#initialize' do
-      it { return_type_for(described, Keymap) }
-      it { assigns(described, '@attributes', { interfaces: [], keys: [] }) }
-    end
-
-    describe '#method_missing' do
-      it 'returns nil' do
-        Keymap.new.some_missing_method(:test).must_equal(nil)
-      end
-    end
-
-  end # Keymap
-
-end # Vedeu

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

@@ -1,246 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Menu do
-
-    let(:described)  { Menu.new(collection) }
-    let(:collection) { ['hydrogen', 'carbon', 'nitrogen', 'oxygen'] }
-    let(:menu)       { Menu.new(collection) }
-
-    describe '#initialize' do
-      it { return_type_for(described, Menu) }
-      it { assigns(described, '@collection', collection) }
-      it { assigns(described, '@name', '') }
-      it { assigns(described, '@current', 0) }
-      it { assigns(described, '@selected', nil) }
-    end
-
-    describe '#current' do
-      it 'returns the current index' do
-        menu.current.must_equal(0)
-      end
-    end
-
-    describe '#selected' do
-      it 'returns nil when no item is selected' do
-        menu.selected.must_equal(nil)
-      end
-
-      it 'returns the selected index when an item is selected' do
-        menu.next_item
-        menu.select_item
-        menu.selected.must_equal(1)
-      end
-    end
-
-    describe '#current_item' do
-      it 'returns the current item from the collection' do
-        menu.current_item.must_equal('hydrogen')
-      end
-
-      it 'when the current item has changed' do
-        menu.next_item
-        menu.next_item
-        menu.current_item.must_equal('nitrogen')
-      end
-    end
-
-    describe '#selected_item' do
-      it 'returns nil when nothing is selected' do
-        menu.selected_item.must_equal(nil)
-      end
-
-      it 'returns the selected item from the collection' do
-        menu.next_item
-        menu.select_item
-        menu.selected_item.must_equal('carbon')
-      end
-    end
-
-    describe '#items' do
-      it 'returns a collection of items' do
-        menu.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
-        menu.next_item
-        menu.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
-        menu.next_item
-        menu.select_item
-        menu.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
-        menu.next_item
-        menu.select_item
-        menu.next_item
-        menu.next_item
-        menu.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
-        menu.top_item
-        menu.next_item
-        menu.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
-        menu.next_item
-        menu.top_item
-        menu.current.must_equal(0)
-      end
-
-      it 'returns the items' do
-        menu.top_item.must_equal(menu.items)
-      end
-    end
-
-    describe '#bottom_item' do
-      it 'sets current to the index of the last item' do
-        menu.bottom_item
-        menu.current.must_equal(3)
-      end
-
-      it 'returns the items' do
-        menu.bottom_item.must_equal(menu.items)
-      end
-    end
-
-    describe '#next_item' do
-      it 'sets the current to the index of the next item' do
-        menu.next_item
-        menu.current.must_equal(1)
-      end
-
-      it 'returns the items' do
-        menu.next_item.must_equal(menu.items)
-      end
-
-      it 'does not loop' do
-        menu.next_item
-        menu.next_item
-        menu.next_item
-        menu.next_item
-        menu.next_item
-        menu.current.must_equal(3)
-      end
-    end
-
-    describe '#prev_item' do
-      it 'does not loop' do
-        menu.prev_item
-        menu.current.must_equal(0)
-      end
-
-      it 'sets the current to the index of the previous item' do
-        menu.next_item
-        menu.next_item
-        menu.prev_item
-        menu.current.must_equal(1)
-      end
-
-      it 'returns the items' do
-        menu.prev_item.must_equal(menu.items)
-      end
-
-      it 'does not loop' do
-        menu.next_item
-        menu.next_item
-        menu.next_item
-        menu.prev_item
-        menu.prev_item
-        menu.current.must_equal(1)
-      end
-    end
-
-    describe '#select_item' do
-      it 'sets the selected index to the current index' do
-        menu.select_item
-        menu.selected.must_equal(0)
-      end
-
-      it 'sets the selected index to the current index' do
-        menu.next_item
-        menu.select_item
-        menu.selected.must_equal(1)
-      end
-
-      it 'returns the items' do
-        menu.select_item.must_equal(menu.items)
-      end
-    end
-
-    describe '#deselect_item' do
-      it 'sets the selected index to nil' do
-        menu.next_item
-        menu.next_item
-        menu.select_item
-        menu.deselect_item
-        menu.selected.must_equal(nil)
-      end
-
-      it 'returns the items' do
-        menu.deselect_item.must_equal(menu.items)
-      end
-    end
-
-    describe '#last' do
-      it 'returns the index of the last item' do
-        menu.last.must_equal(3)
-      end
-    end
-
-    describe '#size' do
-      it 'returns the collection size' do
-        menu.size.must_equal(4)
-      end
-    end
-
-  end # Menu
-
-end # Vedeu

data/test/lib/vedeu/repositories/models/offset_test.rb

@@ -1,128 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Offset do
-    let(:described)  { Offset.new(attributes) }
-    let(:offset)     { Offset.new(attributes) }
-    let(:attributes) { {} }
-
-    before { Offsets.reset }
-
-    describe '#initialize' do
-      it { return_type_for(described, Offset) }
-      it { assigns(described, '@attributes', { name: '', x: 0, y: 0 }) }
-      it { assigns(described, '@name', '') }
-      it { assigns(described, '@y', 0) }
-      it { assigns(described, '@x', 0) }
-    end
-
-    describe '#attributes' do
-      let(:attributes) { { name: 'roentgenium', y: 5, x: 12 } }
-
-      it 'returns the attributes' do
-        offset.attributes.must_equal(attributes)
-      end
-    end
-
-    describe '#move' do
-      let(:attributes) { { name: 'roentgenium' } }
-
-      context 'left' do
-        it 'does not move past the leftmost position' do
-          offset.move(0, -1).x.must_equal(0)
-        end
-
-        context 'when it can move left' do
-          let(:attributes) { { name: 'roentgenium', x: 5 } }
-
-          it 'moves left' do
-            offset.move(0, -1).x.must_equal(4)
-          end
-        end
-      end
-
-      context 'right' do
-        it 'moves right' do
-          offset.move(0, 1).x.must_equal(1)
-        end
-      end
-
-      context 'up' do
-        it 'does not move past the upmost position' do
-          offset.move(-1, 0).y.must_equal(0)
-        end
-
-        context 'when it can move up' do
-          let(:attributes) { { name: 'roentgenium', y: 5 } }
-
-          it 'moves up' do
-            offset.move(-1, 0).y.must_equal(4)
-          end
-        end
-      end
-
-      context 'down' do
-        it 'moves down' do
-          offset.move(1, 0).y.must_equal(1)
-        end
-      end
-    end
-
-    describe '#name' do
-      it 'has a default value of empty string' do
-        offset.name.must_equal('')
-      end
-
-      context 'when a value is set' do
-        let(:attributes) { { name: 'roentgenium' } }
-
-        it 'returns that value' do
-          offset.name.must_equal('roentgenium')
-        end
-      end
-    end
-
-    describe '#y' do
-      it 'has a default value of 0' do
-        offset.y.must_equal(0)
-      end
-
-      context 'when a value is set' do
-        let(:attributes) { { y: 3 } }
-
-        it 'returns that value' do
-          offset.y.must_equal(3)
-        end
-      end
-
-      context 'when a value is set that is < 0' do
-        let(:attributes) { { y: -2 } }
-
-        it { offset.y.must_equal(0) }
-      end
-    end
-
-    describe '#x' do
-      it 'has a default value of 0' do
-        offset.x.must_equal(0)
-      end
-
-      context 'when a value is set' do
-        let(:attributes) { { x: 2 } }
-
-        it 'returns that value' do
-          offset.x.must_equal(2)
-        end
-      end
-
-      context 'when a value is set that is < 0' do
-        let(:attributes) { { x: -2 } }
-
-        it { offset.x.must_equal(0) }
-      end
-    end
-
-  end # Offset
-
-end # Vedeu

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

@@ -1,39 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Offsets do
-
-    before do
-      Interfaces.reset
-      Registrar.record({ name: 'thorium' })
-      Terminal.console.stubs(:print)
-    end
-
-    context 'when no interfaces are defined' do
-      before { Interfaces.reset }
-
-      it { proc { Offsets.down }.must_raise(NoInterfacesDefined) }
-
-      it { proc { Offsets.up }.must_raise(NoInterfacesDefined) }
-
-      it { proc { Offsets.right }.must_raise(NoInterfacesDefined) }
-
-      it { proc { Offsets.left }.must_raise(NoInterfacesDefined) }
-    end
-
-    context 'when there is at least one interface defined' do
-      before { Focus.stubs(:current).returns('thorium') }
-
-      it { Offsets.down.must_be_instance_of(Array) }
-
-      it { Offsets.up.must_be_instance_of(Array) }
-
-      it { Offsets.right.must_be_instance_of(Array) }
-
-      it { Offsets.left.must_be_instance_of(Array) }
-    end
-
-  end # Offsets
-
-end # Vedeu

data/test/lib/vedeu/support/keymap_validator_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe KeymapValidator do
-
-    let(:described) { KeymapValidator.new(storage, key, interface) }
-    let(:storage)   {
-      {
-        'dubnium' => {
-          'a' => proc { :do_something }
-        },
-        '_global_keymap_' => {
-          'g' => proc { :do_something }
-        }
-      }
-    }
-    let(:key)       { 'a' }
-    let(:interface) { 'dubnium' }
-
-    describe '.check' do
-      it 'raises an exception when already in use as a system key' do
-        proc {
-          KeymapValidator.check(storage, :shift_tab, interface)
-        }.must_raise(KeyInUse)
-      end
-
-      it 'raises an exception when already in use as a global key' do
-        proc {
-          KeymapValidator.check(storage, 'g', interface)
-        }.must_raise(KeyInUse)
-      end
-
-      it 'raises an exception when already in use by the interface' do
-        proc {
-          KeymapValidator.check(storage, 'a', interface)
-        }.must_raise(KeyInUse)
-      end
-
-      it 'raises an exception when already in use' do
-        proc { KeymapValidator.check(storage, 'a', '') }.must_raise(KeyInUse)
-      end
-
-      it 'returns true when valid as a global key' do
-        KeymapValidator.check(storage, 'h', '').must_equal(true)
-      end
-
-      it 'returns true when valid as an interface key' do
-        KeymapValidator.check(storage, 'b', 'dubnium').must_equal(true)
-      end
-    end
-
-    describe '#initialize' do
-      it { return_type_for(described, KeymapValidator) }
-      it { assigns(described, '@storage', storage) }
-      it { assigns(described, '@key', key) }
-      it { assigns(described, '@interface', interface) }
-    end
-
-  end # KeymapValidator
-
-end # Vedeu

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

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

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

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Presentation do
-
-    let(:receiver) { PresentationTestClass.new }
-
-    describe '#colour' do
-      it 'returns a Colour instance' do
-        receiver.colour.must_be_instance_of(Colour)
-      end
-    end
-
-    describe '#style' do
-      it 'returns a Style instance' do
-        receiver.style.must_be_instance_of(Style)
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns output' do
-        line = Line.new({
-          colour: {
-            foreground: '#00ff00',
-            background: '#000000'
-          },
-          style: 'normal'
-        })
-        stream = Stream.new({
-          colour: {
-            foreground: '#ff0000',
-            background: '#000000'
-          },
-          text:  'Some text',
-          style: 'underline',
-          width: nil,
-          align: :left,
-          parent: line.view_attributes,
-        })
-        stream.to_s.must_equal(
-          "\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