vedeu 0.0.38 → 0.0.39

data/lib/vedeu/support/translator.rb

@@ -5,11 +5,12 @@ module Vedeu
     end
 
     def initialize(html_colour = '')
-      @html_colour = html_colour || ''
+      @html_colour = html_colour
     end
 
     def translate
       return '' unless valid?
+
       [16, red, green, blue].inject(:+)
     end
 

data/lib/vedeu.rb

@@ -3,8 +3,9 @@ require 'logger'
 
 require_relative 'vedeu/models/builders/command_builder'
 require_relative 'vedeu/models/builders/interface_builder'
-require_relative 'vedeu/repository/event_repository'
-require_relative 'vedeu/support/coordinate'
+require_relative 'vedeu/support/events'
+require_relative 'vedeu/support/geometry'
+require_relative 'vedeu/support/menu'
 require_relative 'vedeu/support/exit'
 require_relative 'vedeu/launcher'
 
@@ -20,17 +21,27 @@ module Vedeu
     end
 
     def event(name, &block)
-      EventRepository.register(name, &block)
+      Vedeu.events.on(name, &block)
     end
+    alias_method :on, :event
 
     def run(name, *args)
-      EventRepository.trigger(name, *args)
+      Vedeu.events.trigger(name, *args)
     end
+    alias_method :trigger, :run
+  end
 
-    private
+  def self.events
+    @events ||= Events.new do
+      on(:_exit_)        { fail StopIteration }
+      on(:_log_)         { |message| Vedeu.logger.debug(message) }
+      on(:_mode_switch_) { fail ModeSwitch    }
 
-    def stringify_symbols(value)
-      value.is_a?(::Symbol) ? value.to_s : value
+      on(:_keypress_) do |key|
+        trigger(:key, key)
+        trigger(:_log_, "key: #{key}")
+        trigger(:_mode_switch_) if key == :escape
+      end
     end
   end
 
@@ -65,9 +76,12 @@ module Vedeu
   end
 
   def self.included(receiver)
+    receiver.send :include, ClassMethods
     receiver.extend(ClassMethods)
   end
 
+  extend ClassMethods
+
   private
 
   def self.root_path

data/test/lib/vedeu/models/builders/builder_test.rb

@@ -0,0 +1,11 @@
+require_relative '../../../../test_helper'
+require_relative '../../../../../lib/vedeu/models/builders/builder'
+
+module Vedeu
+  describe Builder do
+    it 'raises an exception if not subclassed' do
+      builder = Builder.new('builder_test')
+      proc { builder.repository }.must_raise(StandardError)
+    end
+  end
+end

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

@@ -76,18 +76,18 @@ module Vedeu
     end
 
     describe '#geometry' do
-      it 'delegates to the Coordinate class' do
+      it 'delegates to the Geometry class' do
         interface = Interface.new({
           name:   '#geometry',
           width:  5,
           height: 5
         })
-        interface.geometry.must_be_instance_of(Coordinate)
+        interface.geometry.must_be_instance_of(Geometry)
       end
     end
 
     describe '#origin' do
-      it 'delegates to the Coordinate class to get the origin' do
+      it 'delegates to the Geometry class to get the origin' do
         interface = Interface.new({
           name:   '#origin',
           width:  5,

data/test/lib/vedeu/parsing/text_adaptor_test.rb

@@ -44,6 +44,30 @@ module Vedeu
           ]
         )
       end
+
+      it 'handles collections of lines' do
+        text = ["Lorm ipsum door sit amet, consecteur ",
+                "adipscing elit. Curbitur gravda nisl ",
+                "sit amet sagitis digisim. Nibh, eget."]
+        TextAdaptor.adapt(text).size.must_equal(3)
+        TextAdaptor.adapt(text).must_equal(
+          [
+            {
+              streams: {
+                text: "Lorm ipsum door sit amet, consecteur "
+              }
+            }, {
+              streams: {
+                text: "adipscing elit. Curbitur gravda nisl "
+              }
+            }, {
+              streams: {
+                text: "sit amet sagitis digisim. Nibh, eget."
+              }
+            }
+          ]
+        )
+      end
     end
   end
 end

data/test/lib/vedeu/repository/command_repository_test.rb

@@ -37,23 +37,15 @@ module Vedeu
         command.name.wont_equal('banana')
       end
 
-      it 'returns FalseClass when no command was found' do
-        command = CommandRepository.by_input('not_found')
-        command.must_be_instance_of(FalseClass)
+      it 'returns false when no command was found' do
+        CommandRepository.by_input('not_found').must_be_instance_of(FalseClass)
       end
 
-      it 'returns FalseClass when there is no input' do
+      it 'returns false when there is no input' do
         CommandRepository.by_input('').must_be_instance_of(FalseClass)
       end
     end
 
-    describe '.create' do
-      it 'returns a Command' do
-        command = CommandRepository.create({})
-        command.must_be_instance_of(Command)
-      end
-    end
-
     describe '.entity' do
       it 'returns Command' do
         CommandRepository.entity.must_equal(Command)

data/test/lib/vedeu/repository/interface_repository_test.rb

@@ -5,29 +5,6 @@ module Vedeu
   describe InterfaceRepository do
     before { InterfaceRepository.reset }
 
-    describe '.create' do
-      it 'returns an Interface' do
-        InterfaceRepository.create({
-          name:   'dummy',
-          width:  5,
-          height: 5
-        }).must_be_instance_of(Interface)
-      end
-    end
-
-    describe '.find' do
-      it 'returns the interface if it exists' do
-        hydrogen =  InterfaceRepository.create({ name: 'hydrogen' })
-
-        InterfaceRepository.find('hydrogen').must_equal(hydrogen)
-      end
-
-      it 'raises an exception if it does not exist' do
-        proc { InterfaceRepository.find('helium') }
-          .must_raise(UndefinedInterface)
-      end
-    end
-
     describe '.update' do
       it 'returns an Interface' do
         InterfaceRepository.update('dummy', { name: 'dumber' })

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

@@ -3,55 +3,78 @@ require_relative '../../../../lib/vedeu/repository/repository'
 
 module Vedeu
   class Dummy
-    def name
-      'dummy'
+    attr_reader :name
+
+    def initialize(attributes = {})
+      @name = attributes.fetch(:name, '')
     end
   end
 
-  class DummyRepository
+  module DummyRepository
     extend Repository
+    extend self
 
-    def self.entity
+    def entity
       Dummy
     end
   end
 
   describe Repository do
-    describe '#adaptor' do
-      it 'returns a Storage' do
-        DummyRepository.adaptor.must_be_instance_of(Storage)
+    before { DummyRepository.reset }
+
+    describe '#create' do
+      it 'returns a Dummy' do
+        DummyRepository.create({ name: 'dummy' })
+          .must_be_instance_of(Dummy)
+      end
+
+      it 'raises an exception if called directly' do
+        proc { Repository.create({ name: 'test' }) }
+          .must_raise(StandardError)
       end
     end
 
     describe '#all' do
       it 'returns all the stored items' do
-        DummyRepository.all.must_be_instance_of(Array)
+        DummyRepository.all.must_equal([])
+      end
+
+      it 'raises an exception if called directly' do
+        proc { Repository.all }.must_raise(StandardError)
       end
     end
 
     describe '#query' do
-      it 'delegates to the adaptor' do
-        dumb = Dummy.new
-        DummyRepository.create(dumb)
-
-        result = DummyRepository.query(Dummy, :name, 'dummy')
+      it 'finds an entity by attribute' do
+        dumb = DummyRepository.create({ name: 'dummy' })
+        result = DummyRepository.query(:name, 'dummy')
         result.must_equal(dumb)
+      end
 
-        result = DummyRepository.query(Dummy, :name, 'dumber')
-        result.must_equal(false)
+      it 'raises an exception when the entity cannot be found' do
+        proc { DummyRepository.query(:name, 'dumber') }
+          .must_raise(EntityNotFound)
       end
-    end
 
-    describe '#create' do
-      it 'returns a Dummy' do
-        dummy = DummyRepository.create(Dummy.new)
-        DummyRepository.create(dummy).must_be_instance_of(Dummy)
+      it 'raises an exception if called directly' do
+        proc { Repository.query(:name, 'test') }
+          .must_raise(StandardError)
       end
     end
 
     describe '#reset' do
-      it 'returns an Array' do
-        DummyRepository.reset.must_be_instance_of(Array)
+      it 'removes all stored entities' do
+        DummyRepository.reset.must_equal({})
+      end
+
+      it 'raises an exception if called directly' do
+        proc { Repository.reset }.must_raise(StandardError)
+      end
+    end
+
+    describe '#entity' do
+      it 'raises an exception if called directly' do
+        proc { Repository.entity }.must_raise(StandardError)
       end
     end
   end

data/test/lib/vedeu/repository/storage_test.rb

@@ -3,42 +3,67 @@ require_relative '../../../support/dummy_command'
 require_relative '../../../../lib/vedeu/repository/storage'
 
 module Vedeu
+  class DummyRecord
+    attr_reader :name
+
+    def initialize(attributes = {})
+      @name = attributes.fetch(:name, '')
+    end
+  end
+
   describe Storage do
     describe '#create' do
       it 'returns the stored record' do
-        Storage.new.create(DummyCommand.new)
-          .must_be_instance_of(DummyCommand)
-      end
-    end
-
-    describe '#delete' do
-      it 'returns a NilClass' do
-        Storage.new.delete(DummyCommand.new)
-          .must_be_instance_of(NilClass)
+        storage = Storage.new
+        storage.create(DummyRecord, {})
+          .must_be_instance_of(DummyRecord)
       end
     end
 
     describe '#reset' do
-      it 'returns an Array' do
-        Storage.new.reset(nil).must_be_instance_of(Array)
+      it 'deletes all records for this entity' do
+        storage = Storage.new
+        storage.create(DummyRecord, { name: 'dumb' })
+        storage.create(DummyRecord, { name: 'dumber' })
+        storage.all(DummyRecord).size.must_equal(2)
+
+        storage.reset(DummyRecord).must_equal({})
       end
     end
 
     describe '#all' do
-      it 'returns an Array' do
-        Storage.new.all(nil).must_be_instance_of(Array)
+      it 'returns all entity records if an entity is provided' do
+
+      end
+
+      it 'returns all records if no entity provided' do
+
+      end
+
+
+      it 'returns an empty collection when no records were found' do
+        storage = Storage.new
+        storage.all(DummyRecord).must_equal([])
       end
     end
 
     describe '#query' do
-      it 'returns the item if found, otherwise false' do
-        Record   = Struct.new(:name)
+      it 'returns the record if found' do
+        storage  = Storage.new
+        hydrogen = storage.create(DummyRecord, { name: 'hydrogen' })
+
+        storage.query(DummyRecord, :name, 'hydrogen')
+          .must_be_instance_of(DummyRecord)
+        storage.query(DummyRecord, :name, 'hydrogen')
+          .name.must_equal('hydrogen')
+      end
+
+      it 'returns false if the record is not found' do
         storage  = Storage.new
-        hydrogen = storage.create(Record.new('hydrogen'))
+        hydrogen = storage.create(DummyRecord, { name: 'hydrogen' })
 
-        storage.query(Record, :name, nil).must_equal(false)
-        storage.query(Record, :name, 'lithium').must_equal(false)
-        storage.query(Record, :name, 'hydrogen').must_equal(hydrogen)
+        storage.query(DummyRecord, :name, nil).must_equal(false)
+        storage.query(DummyRecord, :name, 'lithium').must_equal(false)
       end
     end
   end

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

@@ -30,9 +30,9 @@ module Vedeu
         }
 
         Compositor.enqueue(attributes)
-        InterfaceRepository.find('Compositor.enqueue_1').dequeue
+        InterfaceRepository.query(:name, 'Compositor.enqueue_1').dequeue
           .must_match(/bd459118e6175689e4394e242debc2ae/)
-        InterfaceRepository.find('Compositor.enqueue_2').dequeue
+        InterfaceRepository.query(:name, 'Compositor.enqueue_2').dequeue
           .must_match(/837acb2cb2ea3ef359257851142a7830/)
       end
     end

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

@@ -0,0 +1,28 @@
+require_relative '../../../test_helper'
+require_relative '../../../../lib/vedeu/support/events'
+
+module Vedeu
+  describe Events do
+    describe '#on' do
+      it 'returns an Array' do
+        events = Events.new
+        events.on(:some_event) { proc { |x| x } }
+          .must_be_instance_of(Array)
+      end
+    end
+
+    describe '#trigger' do
+      it 'returns a collection containing the event when the event is pre-registered' do
+        events = Events.new do
+          on(:_exit_) { fail StopIteration }
+        end
+        proc { events.trigger(:_exit_) }.must_raise(StopIteration)
+      end
+
+      it 'returns an empty collection when the event has not been registered' do
+        events = Events.new
+        events.trigger(:_not_found_).must_be_empty
+      end
+    end
+  end
+end