vedeu 0.6.1 → 0.6.2

data/test/lib/vedeu/events/collection_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Events
+
+    describe Collection do
+
+      let(:described) { Vedeu::Events::Collection }
+      let(:instance)  { described.new }
+
+      it { described.superclass.must_equal(Vedeu::Collection) }
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+      end
+
+    end # Collection
+
+  end # Events
+
+end # Vedeu

data/test/lib/vedeu/events/event_test.rb

@@ -2,108 +2,112 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Event do
+  module Events
 
-    let(:described)  { Vedeu::Event }
-    let(:instance)   { described.new(event_name, closure, options) }
-    let(:event_name) { :some_event }
-    let(:closure)    { proc { :event_triggered } }
-    let(:options)    { {} }
+    describe Event do
 
-    describe '.bind' do
-      subject { described.bind(event_name, options) { :event_triggered } }
+      let(:described)  { Vedeu::Events::Event }
+      let(:instance)   { described.new(event_name, closure, options) }
+      let(:event_name) { :some_event }
+      let(:closure)    { proc { :event_triggered } }
+      let(:options)    { {} }
 
-      it { described.must_respond_to(:event) }
-      it { described.must_respond_to(:register) }
-      it { subject.must_be_instance_of(TrueClass) }
-    end
+      describe '.bind' do
+        subject { described.bind(event_name, options) { :event_triggered } }
 
-    describe '.bound?' do
-      subject { described.bound?(event_name) }
-
-      context 'when the event is registered' do
-        before { Vedeu.bind(event_name) }
-        after  { Vedeu.unbind(event_name) }
-
-        it { subject.must_equal(true) }
+        it { described.must_respond_to(:event) }
+        it { described.must_respond_to(:register) }
+        it { subject.must_be_instance_of(TrueClass) }
       end
 
-      context 'when the event is not registered' do
-        before { Vedeu.unbind(event_name) }
+      describe '.bound?' do
+        subject { described.bound?(event_name) }
 
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '.unbind' do
-      it { described.must_respond_to(:unbind ) }
-    end
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(event_name) }
-      it { instance.instance_variable_get('@options').must_equal(options) }
-      it { instance.instance_variable_get('@deadline').must_equal(0) }
-      it { instance.instance_variable_get('@executed_at').must_equal(0) }
-      it { instance.instance_variable_get('@now').must_equal(0) }
-      it do
-        instance.instance_variable_get('@repository').must_equal(Vedeu.events)
-      end
-    end
+        context 'when the event is registered' do
+          before { Vedeu.bind(event_name) }
+          after  { Vedeu.unbind(event_name) }
 
-    describe '#bind' do
-      subject { instance.bind }
+          it { subject.must_equal(true) }
+        end
 
-      context 'when the event name is already registered' do
-        before { Vedeu.bind(:some_event) { :already_registered } }
+        context 'when the event is not registered' do
+          before { Vedeu.unbind(event_name) }
 
-        it { subject.must_be_instance_of(TrueClass) }
+          it { subject.must_equal(false) }
+        end
       end
 
-      context 'when the event name is not already registered' do
-        it { subject.must_be_instance_of(TrueClass) }
+      describe '.unbind' do
+        it { described.must_respond_to(:unbind ) }
       end
-    end
-
-    describe '#trigger' do
-      it 'returns the result of calling the closure when debouncing' do
-        event = Event.new(event_name, closure, { debounce: 0.001 })
-        event.trigger.must_equal(nil)
-        sleep 0.0005
-        event.trigger.must_equal(nil)
-        sleep 0.0009
-        event.trigger.must_equal(:event_triggered)
-        sleep 0.0001
-        event.trigger.must_equal(nil)
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(event_name) }
+        it { instance.instance_variable_get('@options').must_equal(options) }
+        it { instance.instance_variable_get('@deadline').must_equal(0) }
+        it { instance.instance_variable_get('@executed_at').must_equal(0) }
+        it { instance.instance_variable_get('@now').must_equal(0) }
+        it do
+          instance.instance_variable_get('@repository').must_equal(Vedeu.events)
+        end
       end
 
-      it 'returns the result of calling the closure when throttling' do
-        event = Event.new(event_name, closure, { delay: 0.001 })
-        event.trigger.must_equal(:event_triggered)
-        sleep 0.0005
-        event.trigger.must_equal(nil)
-        sleep 0.0005
-        event.trigger.must_equal(:event_triggered)
+      describe '#bind' do
+        subject { instance.bind }
+
+        context 'when the event name is already registered' do
+          before { Vedeu.bind(:some_event) { :already_registered } }
+
+          it { subject.must_be_instance_of(TrueClass) }
+        end
+
+        context 'when the event name is not already registered' do
+          it { subject.must_be_instance_of(TrueClass) }
+        end
       end
 
-      it 'returns the result of calling the closure with its arguments' do
-        event = Event.new(event_name, closure, options)
-        event.trigger.must_equal(:event_triggered)
+      describe '#trigger' do
+        it 'returns the result of calling the closure when debouncing' do
+          event = described.new(event_name, closure, { debounce: 0.001 })
+          event.trigger.must_equal(nil)
+          sleep 0.0005
+          event.trigger.must_equal(nil)
+          sleep 0.0009
+          event.trigger.must_equal(:event_triggered)
+          sleep 0.0001
+          event.trigger.must_equal(nil)
+        end
+
+        it 'returns the result of calling the closure when throttling' do
+          event = described.new(event_name, closure, { delay: 0.001 })
+          event.trigger.must_equal(:event_triggered)
+          sleep 0.0005
+          event.trigger.must_equal(nil)
+          sleep 0.0005
+          event.trigger.must_equal(:event_triggered)
+        end
+
+        it 'returns the result of calling the closure with its arguments' do
+          event = described.new(event_name, closure, options)
+          event.trigger.must_equal(:event_triggered)
+        end
       end
-    end
 
-    describe '#unbind' do
-      context 'when the event exists' do
-        before { Vedeu.bind(:gallium) { :some_action } }
+      describe '#unbind' do
+        context 'when the event exists' do
+          before { Vedeu.bind(:gallium) { :some_action } }
 
-        it { Vedeu.unbind(:gallium).must_equal(true) }
-      end
+          it { Vedeu.unbind(:gallium).must_equal(true) }
+        end
 
-      context 'when the event does not exist' do
-        it { Vedeu.unbind(:gallium).must_equal(false) }
+        context 'when the event does not exist' do
+          it { Vedeu.unbind(:gallium).must_equal(false) }
+        end
       end
-    end
 
-  end # Event
+    end # Event
+
+  end # Events
 
 end # Vedeu

data/test/lib/vedeu/events/repository_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Events
+
+    describe Repository do
+
+      let(:described) { Vedeu::Events::Repository }
+
+      it { described.must_respond_to(:events) }
+
+      describe '.reset!' do
+        subject { described.reset! }
+
+        it { described.must_respond_to(:reset) }
+
+        it {
+          described.expects(:new).with(Vedeu::Events::Collection)
+          subject
+        }
+      end
+
+    end # Repository
+
+  end # Events
+
+end # Vedeu

data/test/lib/vedeu/events/trigger_test.rb

@@ -2,59 +2,63 @@ require 'test_helper'
 
 module Vedeu
 
-  describe Trigger do
+  module Events
 
-    let(:described)  { Vedeu::Trigger }
-    let(:instance)   { described.new(event_name, args) }
-    let(:event_name) { :_testing_event_ }
-    let(:args)       {}
+    describe Trigger do
 
-    describe '.trigger' do
-      before { Vedeu.bind(event_name) { :_only_one_result_ } }
+      let(:described)  { Vedeu::Events::Trigger }
+      let(:instance)   { described.new(event_name, args) }
+      let(:event_name) { :_testing_event_ }
+      let(:args)       {}
 
-      subject { described.trigger(event_name) }
+      describe '.trigger' do
+        before { Vedeu.bind(event_name) { :_only_one_result_ } }
 
-      it { subject.must_equal(:_only_one_result_) }
-    end
+        subject { described.trigger(event_name) }
 
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@name').must_equal(event_name) }
-      it { instance.instance_variable_get('@args').must_equal([args]) }
-      it do
-        instance.instance_variable_get('@repository').must_equal(Vedeu.events)
+        it { subject.must_equal(:_only_one_result_) }
       end
-    end
 
-    describe '#trigger' do
-      subject { instance.trigger }
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@name').must_equal(event_name) }
+        it { instance.instance_variable_get('@args').must_equal([args]) }
+        it do
+          instance.instance_variable_get('@repository').must_equal(Vedeu.events)
+        end
+      end
 
-      context 'when only one result occurs from triggering the event' do
-        let(:event_name) { :_one_result_ }
+      describe '#trigger' do
+        subject { instance.trigger }
 
-        before { Vedeu.bind(event_name) { :_only_one_result_ } }
+        context 'when only one result occurs from triggering the event' do
+          let(:event_name) { :_one_result_ }
 
-        it { subject.must_equal(:_only_one_result_) }
-      end
+          before { Vedeu.bind(event_name) { :_only_one_result_ } }
 
-      context 'when multiple results occur from triggering an event' do
-        let(:event_name) { :_multiple_results_ }
+          it { subject.must_equal(:_only_one_result_) }
+        end
 
-        before {
-          Vedeu::Event.register(event_name) { :_result_one_ }
-          Vedeu::Event.register(event_name) { :_result_two_ }
-        }
+        context 'when multiple results occur from triggering an event' do
+          let(:event_name) { :_multiple_results_ }
 
-        it { subject.must_equal([:_result_one_, :_result_two_]) }
-      end
+          before {
+            Vedeu::Events::Event.register(event_name) { :_result_one_ }
+            Vedeu::Events::Event.register(event_name) { :_result_two_ }
+          }
 
-      context 'when the event has not been registered' do
-        let(:event_name) { :_not_found_ }
+          it { subject.must_equal([:_result_one_, :_result_two_]) }
+        end
 
-        it { subject.must_equal([]) }
+        context 'when the event has not been registered' do
+          let(:event_name) { :_not_found_ }
+
+          it { subject.must_equal([]) }
+        end
       end
-    end
 
-  end # Trigger
+    end # Trigger
+
+  end # Events
 
 end # Vedeu

data/test/lib/vedeu/geometry/grid_test.rb

@@ -17,11 +17,11 @@ module Vedeu
 
     describe '.columns' do
       context 'when the value is less than 1' do
-        it { proc { Grid.columns(0) }.must_raise(Vedeu::OutOfRange) }
+        it { proc { Grid.columns(0) }.must_raise(Vedeu::Error::OutOfRange) }
       end
 
       context 'when the value is greater than 12' do
-        it { proc { Grid.columns(13) }.must_raise(Vedeu::OutOfRange) }
+        it { proc { Grid.columns(13) }.must_raise(Vedeu::Error::OutOfRange) }
       end
 
       context 'when the value is in range' do
@@ -33,11 +33,11 @@ module Vedeu
 
     describe '.rows' do
       context 'when the value is less than 1' do
-        it { proc { Grid.rows(0) }.must_raise(Vedeu::OutOfRange) }
+        it { proc { Grid.rows(0) }.must_raise(Vedeu::Error::OutOfRange) }
       end
 
       context 'when the value is greater than 12' do
-        it { proc { Grid.rows(13) }.must_raise(Vedeu::OutOfRange) }
+        it { proc { Grid.rows(13) }.must_raise(Vedeu::Error::OutOfRange) }
       end
 
       context 'when the value is in range' do

data/test/lib/vedeu/input/editor/{virtual_cursor_test.rb → cursor_test.rb}

@@ -4,9 +4,9 @@ module Vedeu
 
   module Editor
 
-    describe VirtualCursor do
+    describe Cursor do
 
-      let(:described)  { Vedeu::Editor::VirtualCursor }
+      let(:described)  { Vedeu::Editor::Cursor }
       let(:instance)   { described.new(attributes) }
       let(:attributes) {
         {
@@ -183,7 +183,7 @@ module Vedeu
         # it { skip }
       end
 
-    end # VirtualCursor
+    end # Cursor
 
   end # Editor
 

data/test/lib/vedeu/input/editor/insert_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+module Vedeu
+
+  module Editor
+
+    describe Insert do
+
+      let(:described)  { Vedeu::Editor::Insert }
+      let(:instance)   { described.new(collection, entity, index, size) }
+      let(:collection) {}
+      let(:entity)     {}
+      let(:index)      {}
+      let(:size)       {}
+
+      describe '#initialize' do
+        it { instance.must_be_instance_of(described) }
+        it { instance.instance_variable_get('@collection').must_equal(collection) }
+        it { instance.instance_variable_get('@entity').must_equal(entity) }
+        it { instance.instance_variable_get('@index').must_equal(index) }
+        it { instance.instance_variable_get('@size').must_equal(size) }
+      end
+
+      describe '.into' do
+        subject { described.into(collection, entity, index, size) }
+      end
+
+      describe '#insert' do
+        it { instance.must_respond_to(:insert) }
+      end
+
+    end # Insert
+
+  end # Editor
+
+end # Vedeu

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

@@ -15,7 +15,7 @@ module Vedeu
       context 'when the required block is not given' do
         subject { described.new(input) }
 
-        it { proc { subject }.must_raise(Vedeu::InvalidSyntax) }
+        it { proc { subject }.must_raise(Vedeu::Error::InvalidSyntax) }
       end
     end
 

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

@@ -15,7 +15,7 @@ module Vedeu
         y:      y,
       }
     }
-    let(:colour) { Colour.new(background: '#000000') }
+    let(:colour) { Vedeu::Colours::Colour.new(background: '#000000') }
     let(:style)  {}
     let(:_value) {}
     let(:x)      {}