vedeu 0.2.12 → 0.3.0

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

@@ -1,223 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Keymaps do
-
-    before { Keymaps.reset }
-
-    describe '#add' do
-      it 'returns false when there are no keys defined' do
-        attributes = {}
-
-        Keymaps.add(attributes).must_equal(false)
-      end
-
-      it 'returns true when the key was registered with keymap storage' do
-        attributes = { interfaces: ['gold'], keys: [{ 'a' => proc { :gold } }] }
-
-        Keymaps.add(attributes).must_equal(true)
-      end
-    end
-
-    describe '#find' do
-      let(:attributes) {
-        {
-          interfaces: ['flerovium'],
-          keys: [{ key: 'u', action: proc { :some_action } }]
-        }
-      }
-
-      before { Keymaps.add(attributes) }
-
-      it 'returns false when the named keymap cannot be found' do
-        Keymaps.find('vanadium').must_equal({})
-      end
-
-      it 'returns the keymap when the named keymap was found' do
-        Keymaps.find('flerovium').wont_be_empty
-      end
-    end
-
-    describe '#global_key?' do
-      before { Keymaps.stubs(:global_keys).returns(['i', 'j']) }
-
-      it 'returns false when the key is not registered as a global key' do
-        Keymaps.global_key?('h').must_equal(false)
-      end
-
-      it 'returns true when the key is registered as a global key' do
-        Keymaps.global_key?('j').must_equal(true)
-      end
-    end
-
-    describe '#global_keys' do
-      let(:attributes) {
-        {
-          keys: [
-            {
-              key: 'a', action: proc { :action_a }
-            },{
-              key: 'b', action: proc { :action_b }
-            },{
-              key: 'c', action: proc { :action_c }
-            }
-          ]
-        }
-      }
-
-      before { Keymaps.add(attributes) }
-
-      it 'returns the defined global keys' do
-        Keymaps.global_keys.must_equal(['a', 'b', 'c'])
-      end
-    end
-
-    describe '#interface_key?' do
-      before { Keymaps.stubs(:interface_keys).returns(['g', 'h']) }
-
-      it 'returns false when the key is not registered with an interface' do
-        Keymaps.interface_key?('f').must_equal(false)
-      end
-
-      it 'returns true when the key is registered with an interface' do
-        Keymaps.interface_key?('g').must_equal(true)
-      end
-
-      context 'when the interface argument is provided' do
-        before do
-          Keymaps.stubs(:find).returns({ 'j' => proc { :some_action } })
-        end
-
-        it 'return false when the key is not registered with the specified ' \
-           'interface' do
-          Keymaps.interface_key?('k', 'cadmium').must_equal(false)
-        end
-
-        it 'return true when the key is registered with the specified ' \
-           'interface' do
-          Keymaps.interface_key?('j', 'cadmium').must_equal(true)
-        end
-      end
-    end
-
-    describe '#interface_keys' do
-      let(:rhodium_attributes) {
-        {
-          interfaces: ['rhodium'],
-          keys: [
-            {
-              key: 'd', action: proc { :action_d }
-            },{
-              key: 'e', action: proc { :action_e }
-            }
-          ]
-        }
-      }
-      let(:magnesium_attributes) {
-        {
-          interfaces: ['magnesium'],
-          keys: [
-            {
-              key: 'e', action: proc { :action_e }
-            },{
-              key: 'f', action: proc { :action_g }
-            }
-          ]
-        }
-      }
-
-      before do
-        Keymaps.add(rhodium_attributes)
-        Keymaps.add(magnesium_attributes)
-      end
-
-      it 'returns the defined keys for all interfaces' do
-        Keymaps.interface_keys.must_equal(['d', 'e', 'f'])
-      end
-
-      it 'returns the defined keys for the specified interface' do
-        Keymaps.interface_keys('magnesium').must_equal(['e', 'f'])
-      end
-    end
-
-    describe '#registered?' do
-      it 'returns false when the named keymap is not registered' do
-        Keymaps.registered?('vanadium').must_equal(false)
-      end
-
-      it 'returns true when the named keymap is registered' do
-        Keymaps.registered?('_global_keymap_').must_equal(true)
-      end
-    end
-
-    describe '#system_key?' do
-      it 'returns false when the key is not registered as a system key' do
-        Keymaps.system_key?('r').must_equal(false)
-      end
-
-      it 'returns true when the key is registered as a system key' do
-        Keymaps.system_key?('q').must_equal(true)
-      end
-    end
-
-    describe '#system_keys' do
-      it 'returns the defined system keys' do
-        Keymaps.system_keys.must_equal(['q', :tab, :shift_tab, :escape])
-      end
-    end
-
-    describe '#use' do
-      let(:meitnerium_attributes) {
-        {
-          interfaces: ['meitnerium'],
-          keys: [{
-            key: 'm', action: proc { :key_m_pressed }
-          }]
-        }
-      }
-      let(:global_attributes) {
-        {
-          keys: [{
-            key: 'o', action: proc { :key_o_pressed }
-          }]
-        }
-      }
-
-      before do
-        Keymaps.add(meitnerium_attributes)
-        Keymaps.add(global_attributes)
-        Vedeu::Focus.stubs(:current).returns('meitnerium')
-        Vedeu::Configuration.stubs(:system_keys).returns({ :key_p_pressed => 'p' })
-        Vedeu.stubs(:trigger).returns(:system_key_p_pressed)
-      end
-
-      context 'when not registered' do
-        it 'returns false' do
-          Keymaps.use('l').must_equal(false)
-        end
-      end
-
-      context 'when registered as an interface key and the interface is in ' \
-              'focus' do
-        it 'returns the result of the keypress' do
-          Keymaps.use('m').must_equal(:key_m_pressed)
-        end
-      end
-
-      context 'when registered as a global key' do
-        it 'returns the result of the keypress' do
-          Keymaps.use('o').must_equal(:key_o_pressed)
-        end
-      end
-
-      context 'when registered as a system key' do
-        it 'returns the result of the keypress' do
-          Keymaps.use('p').must_equal(:system_key_p_pressed)
-        end
-      end
-    end
-
-  end # Keymaps
-
-end # Vedeu

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

@@ -1,174 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Buffer do
-
-    let(:described) { Buffer.new(attributes) }
-    let(:attributes) {
-      {
-        name:     '',
-        back:     back,
-        front:    front,
-        previous: previous,
-      }
-    }
-    let(:back)     { {} }
-    let(:front)    { {} }
-    let(:previous) { {} }
-
-    describe '#initialize' do
-      it { return_type_for(described, Buffer) }
-      it { assigns(described, '@name', '') }
-      it { assigns(described, '@back', {}) }
-      it { assigns(described, '@front', {}) }
-      it { assigns(described, '@previous', {}) }
-    end
-
-    describe '#back' do
-      it { return_type_for(described.back, Hash) }
-    end
-
-    describe '#front' do
-      it { return_type_for(described.front, Hash) }
-
-      context 'alias method: #current' do
-        it { return_type_for(described.current, Hash) }
-      end
-    end
-
-    describe '#name' do
-      it { return_type_for(described.name, String) }
-    end
-
-    describe '#previous' do
-      it { return_type_for(described.previous, Hash) }
-    end
-
-    describe '#content' do
-      it { return_type_for(described.content, Array) }
-
-      subject { Buffer.new(attributes).content }
-
-      context 'when there is content on the back buffer' do
-        let(:back) { { lines: [{ streams: [{ text: 'back' }] }] } }
-        let(:buffer) { :back }
-
-        it { subject.must_equal([{}, back]) }
-      end
-
-      context 'when there is no content on the back buffer' do
-        let(:buffer) { :back }
-
-        it { subject.must_equal([{}]) }
-      end
-
-      context 'when there is no content on the back buffer' do
-        let(:back) { { lines: [] } }
-        let(:buffer) { :back }
-
-        it { subject.must_equal([{}]) }
-      end
-
-      context 'when there is content on the front buffer' do
-        let(:buffer) { :front }
-        let(:front) { { lines: [{ streams: [{ text: 'front' }] }] } }
-
-        it { subject.must_equal([front]) }
-      end
-
-      context 'when there is no content on the front buffer' do
-        let(:buffer) { :front }
-
-        it { subject.must_equal([{}]) }
-      end
-
-      context 'when there is no content on the front buffer' do
-        let(:buffer) { :front }
-
-        let(:front) { { lines: [] } }
-
-        it { subject.must_equal([{}]) }
-      end
-
-      context 'when there is content on the previous buffer' do
-        let(:buffer) { :previous }
-        let(:previous) { { lines: [{ streams: [{ text: 'previous' }] }] } }
-
-        it { subject.must_equal([previous]) }
-      end
-
-      context 'when there is no content on the previous buffer' do
-        let(:buffer) { :previous }
-
-        it { subject.must_equal([{}]) }
-      end
-
-      context 'when there is no content on the previous buffer' do
-        let(:buffer) { :previous }
-        let(:previous) { { lines: [] } }
-
-        it { subject.must_equal([{}]) }
-      end
-    end
-
-    describe '#add' do
-      let(:attributes) {
-        {
-          back: { lines: [{ streams: [{ text: 'old_back' }] }] }
-        }
-      }
-      let(:buffer)  { Buffer.new(attributes) }
-      let(:content) { { lines: [{ streams: [{ text: 'new_back' }] }] } }
-
-      subject { buffer.add(content) }
-
-      it { subject.must_equal(true) }
-
-      it 'replaces the back buffer with the content' do
-        buffer.back.must_equal({ lines: [{ streams: [{ text: 'old_back' }] }] })
-
-        subject
-
-        buffer.back.must_equal({ lines: [{ streams: [{ text: 'new_back' }] }] })
-      end
-    end
-
-    describe '#swap' do
-      let(:buffer) { Buffer.new(attributes) }
-
-      subject { buffer.swap }
-
-      context 'when there is new content on the back buffer' do
-        let(:back)     { { lines: [{ streams: [{ text: 'back' }] }] } }
-        let(:front)    { { lines: [{ streams: [{ text: 'front' }] }] } }
-        let(:previous) { { lines: [{ streams: [{ text: 'previous' }] }] } }
-
-        context 'when the buffer was updated successfully' do
-          it { subject.must_equal(true) }
-        end
-
-        it 'replaces the previous buffer with the front buffer' do
-          subject
-          buffer.previous.must_equal(front)
-        end
-
-        it 'replaces the front buffer with the back buffer' do
-          subject
-          buffer.front.must_equal(back)
-        end
-
-        it 'replaces the back buffer with an empty buffer' do
-          subject
-          buffer.back.must_equal({})
-        end
-      end
-
-      context 'when there is no new content on the back buffer' do
-        it { subject.must_equal(false) }
-      end
-    end
-
-  end # Buffer
-
-end # Vedeu

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

@@ -1,158 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Cursor do
-
-    let(:described)  { Cursor.new(attributes) }
-    let(:attributes) {
-      {
-        name:  'silver',
-        state: :show,
-        x:     19,
-        y:     8
-      }
-    }
-
-    before do
-      Interfaces.reset
-      Vedeu.interface 'silver' do
-        y      5
-        height 4
-        x      12
-        width  10
-      end
-      Terminal.console.stubs(:print)
-    end
-
-    describe '#initialize' do
-      it { return_type_for(described, Cursor) }
-      it { assigns(described, '@attributes', attributes) }
-      it { assigns(described, '@name', 'silver') }
-      it { assigns(described, '@state', :show) }
-      it { assigns(described, '@x', 19) }
-      it { assigns(described, '@y', 8) }
-    end
-
-    describe '#attributes' do
-      it 'returns a hash containing the attributes of the instance' do
-        described.attributes.must_equal(
-          { name: 'silver', state: :show, x: 19, y: 8 }
-        )
-      end
-    end
-
-    describe '#x' do
-      it { return_type_for(described.x, Fixnum) }
-
-      context 'when the cursors position is outside the interface' do
-        let(:attributes) { { name: 'silver', state: :show, x: 10, y: 8 } }
-
-        it 'repositions the cursor at the start of the line' do
-          Cursor.new(attributes).attributes.must_equal(
-            { name: 'silver', state: :show, x: 12, y: 8 }
-          )
-        end
-      end
-
-      context 'when the cursors position is outside the interface' do
-        let(:attributes) { { name: 'silver', state: :show, x: 25, y: 8 } }
-
-        it 'repositions the cursor at the end of the line' do
-          Cursor.new(attributes).attributes.must_equal(
-            { name: 'silver', state: :show, x: 22, y: 8 }
-          )
-        end
-      end
-    end
-
-    describe '#y' do
-      it { return_type_for(described.y, Fixnum) }
-
-      context 'when the cursors position is outside the interface' do
-        let(:attributes) { { name: 'silver', state: :show, x: 19, y: 3 } }
-
-        it 'repositions the cursor at the start of the line' do
-          described.attributes.must_equal(
-            { name: 'silver', state: :show, x: 19, y: 5 }
-          )
-        end
-      end
-
-      context 'when the cursors position is outside the interface' do
-        let(:attributes) { { name: 'silver', state: :show, x: 19, y: 12 } }
-
-        it 'repositions the cursor at the end of the line' do
-          described.attributes.must_equal(
-            { name: 'silver', state: :show, x: 19, y: 9 }
-          )
-        end
-      end
-    end
-
-    describe '#refresh' do
-      it 'returns a hash containing the attributes of the instance' do
-        described.refresh.must_equal(
-          { name: 'silver', state: :show, x: 19, y: 8 }
-        )
-      end
-    end
-
-    describe '#show' do
-      it 'sets the state attribute to :show' do
-        cursor = described
-        cursor.hide
-        cursor.attributes.must_equal(
-          { name: 'silver', state: :hide, x: 19, y: 8 }
-        )
-        cursor.show
-        cursor.attributes.must_equal(
-          { name: 'silver', state: :show, x: 19, y: 8 }
-        )
-      end
-    end
-
-    describe '#hide' do
-      it 'sets the state attribute to :hide' do
-        cursor = described
-        cursor.hide
-        cursor.attributes.must_equal(
-          { name: 'silver', state: :hide, x: 19, y: 8 }
-        )
-        cursor.to_s.must_equal("\e[8;19H\e[?25l")
-      end
-    end
-
-    describe '#to_s' do
-      context 'when the cursor state is :show' do
-        it 'returns an escape sequence for showing the cursor (and position)' do
-          cursor = described
-          cursor.show
-          cursor.to_s.must_equal("\e[8;19H\e[?25h")
-        end
-      end
-
-      context 'when the cursor state is :hide' do
-         it 'returns an escape sequence for hiding the cursor (and position)' do
-          cursor = described
-          cursor.hide
-          cursor.to_s.must_equal("\e[8;19H\e[?25l")
-        end
-      end
-
-      it 'returns the escape sequence to position and set the visibility of ' \
-         'the cursor' do
-        described.to_s.must_equal("\e[8;19H\e[?25h")
-      end
-
-      it 'returns the escape sequence to position and set the visibility of ' \
-         'the cursor and returns to that position after yielding the block' do
-        described.to_s do
-          # ...
-        end.must_equal("\e[8;19H\e[?25h\e[8;19H\e[?25h")
-      end
-    end
-
-  end # Cursor
-
-end # Vedeu

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

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Event do
-
-    let(:described)  { Event.new(event_name, options, closure) }
-    let(:event_name) { :some_event }
-    let(:options)    { {} }
-    let(:closure)    { proc { :event_triggered } }
-
-    describe '#initialize' do
-      it { return_type_for(described, Event) }
-      it { assigns(described, '@name', :some_event) }
-      it { assigns(described, '@options', options) }
-
-      it { skip; assigns(described, '@closure', closure) }
-
-      it { assigns(described, '@deadline', 0) }
-      it { assigns(described, '@executed_at', 0) }
-      it { assigns(described, '@now', 0) }
-    end
-
-    describe '#trigger' do
-      it 'returns the result of calling the closure when debouncing' do
-        event = Event.new(event_name, { debounce: 0.0025 }, closure)
-        event.trigger.must_equal(nil)
-        sleep 0.0015
-        event.trigger.must_equal(nil)
-        sleep 0.0015
-        event.trigger.must_equal(:event_triggered)
-        sleep 0.0015
-        event.trigger.must_equal(nil)
-      end
-
-      it 'returns the result of calling the closure when throttling' do
-        event = Event.new(event_name, { delay: 0.0025 }, closure)
-        event.trigger.must_equal(:event_triggered)
-        sleep 0.0015
-        event.trigger.must_equal(nil)
-        sleep 0.0015
-        event.trigger.must_equal(:event_triggered)
-      end
-
-      it 'returns the result of calling the closure with its arguments' do
-        event = Event.new(event_name, options, closure)
-        event.trigger.must_equal(:event_triggered)
-      end
-    end
-
-  end # Event
-
-end # Vedeu

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

@@ -1,98 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Group do
-
-    let(:described) { Group.new('organics', *members) }
-    let(:members)   { ['carbon', 'nitrogen', 'oxygen'] }
-
-    describe '#initialize' do
-      it { return_type_for(described, Group) }
-      it { assigns(described, '@members', members.to_set) }
-      it { assigns(described, '@name', 'organics') }
-    end
-
-    describe '#add' do
-      it 'returns a Group' do
-        Group.new('organics', 'carbon', 'nitrogen').add('oxygen').must_be_instance_of(Group)
-      end
-
-      context 'when the member already exists' do
-        it 'does not add the member again but returns a new Group' do
-          group = Group.new('organics', 'nitrogen', 'carbon')
-          new_group = group.add('nitrogen')
-          new_group.members.must_equal(['nitrogen', 'carbon'])
-        end
-      end
-
-      context 'when the member does not exist' do
-        it 'adds the member and returns a new Group' do
-          group = Group.new('organics', 'carbon')
-          new_group = group.add('nitrogen')
-          new_group.members.must_equal(['carbon', 'nitrogen'])
-        end
-      end
-    end
-
-    describe '#members' do
-      it { return_type_for(described.members, Array) }
-
-      context 'when the group has no members' do
-        it 'returns an empty Set' do
-          group = Group.new('organics')
-          group.members.must_be_empty
-        end
-      end
-
-      context 'when the group has members' do
-        it 'returns a set of members' do
-          group = Group.new('organics', 'nitrogen', 'carbon')
-          group.members.wont_be_empty
-        end
-      end
-    end
-
-    describe '#name' do
-      it 'returns the specified name for the group' do
-        Group.new('organics').name.must_equal('organics')
-      end
-    end
-
-    describe '#remove' do
-      it 'returns a Group' do
-        group = Group.new('organics')
-        group.members.must_be_empty
-        group.remove('nitrogen').must_be_instance_of(Group)
-      end
-
-      context 'when the member exists' do
-        it 'removes the member and returns a new Group' do
-          group     = Group.new('organics', 'nitrogen', 'carbon')
-          new_group = group.remove('nitrogen')
-          new_group.members.wont_include('nitrogen')
-        end
-      end
-
-      context 'when the member does not exist' do
-        it 'returns a new Group' do
-          group     = Group.new('organics', 'nitrogen', 'carbon')
-          new_group = group.remove('oxygen')
-          new_group.members.must_equal(['nitrogen', 'carbon'])
-        end
-      end
-    end
-
-    describe '#reset' do
-      it { return_type_for(described.reset, Group) }
-
-      it 'returns a Group with no members' do
-        group     = Group.new('organics', 'nitrogen', 'carbon')
-        new_group = group.reset
-        new_group.members.must_be_empty
-      end
-    end
-
-  end # Group
-
-end # Vedeu