vedeu 0.6.1 → 0.6.2

data/lib/vedeu/events/event_aliases.rb

@@ -1,87 +0,0 @@
-module Vedeu
-
-  # Allows the storing of event aliases. Each alias can contain multiple event
-  # names.
-  #
-  module EventAliases
-
-    extend self
-
-    # @param alias_name [Symbol]
-    # @param event_name [Symbol]
-    # @return [Hash<Symbol => Array<Symbol>>]
-    def add(alias_name, event_name)
-      storage[alias_name] << event_name
-    end
-    alias_method :bind_alias, :add
-
-    # Return a boolean indicating whether the storage is empty.
-    #
-    # @return [Boolean]
-    def empty?
-      storage.empty?
-    end
-
-    # @param alias_name [Symbol]
-    # @return [Array<Symbol>]
-    def find(alias_name)
-      storage[alias_name]
-    end
-
-    # Returns a boolean indicating whether the alias is registered.
-    #
-    # @param alias_name [Symbol]
-    # @return [Boolean]
-    def registered?(alias_name)
-      return false if alias_name.nil? || alias_name.empty?
-      return false if empty?
-
-      storage.include?(alias_name)
-    end
-
-    # @param alias_name [Symbol]
-    # @return [FalseClass|Hash<Symbol => Array<Symbol>>]
-    def remove(alias_name)
-      return false if empty?
-      return false unless registered?(alias_name)
-
-      storage.delete(alias_name)
-      storage
-    end
-    alias_method :unbind_alias, :remove
-
-    # @return [Hash<Symbol => Array<Symbol>>]
-    def reset
-      @storage = in_memory
-    end
-    alias_method :reset!, :reset
-
-    # Access to the storage for this repository.
-    #
-    # @return [Hash<Symbol => Array<Symbol>>]
-    def storage
-      @storage ||= in_memory
-    end
-
-    # @param alias_name [Symbol]
-    # @param args [void]
-    # @return [FalseClass|Array<void>|void]
-    def trigger(alias_name, *args)
-      return [] unless registered?(alias_name)
-
-      storage[alias_name].map do |event_name|
-        Vedeu.log(type: :debug, message: "#{event_name}")
-        Vedeu::Trigger.trigger(event_name, *args)
-      end
-    end
-
-    private
-
-    # @return [Hash<Symbol => Array<Symbol>>]
-    def in_memory
-      Hash.new { |hash, key| hash[key] = [] }
-    end
-
-  end # EventAliases
-
-end # Vedeu

data/lib/vedeu/events/event_collection.rb

@@ -1,9 +0,0 @@
-module Vedeu
-
-  # A collection of {Vedeu::Event} instances.
-  #
-  class EventCollection < Vedeu::Collection
-
-  end # EventCollection
-
-end # Vedeu

data/lib/vedeu/events/events.rb

@@ -1,26 +0,0 @@
-module Vedeu
-
-  # Allows the storing of events.
-  #
-  class Events < Vedeu::Repository
-
-    singleton_class.send(:alias_method, :events, :repository)
-
-    class << self
-
-      # Remove all stored models from the repository.
-      #
-      # @example
-      #   Vedeu.events.reset!
-      #
-      # @return [Vedeu::Events]
-      def reset!
-        @events = new(Vedeu::EventCollection)
-      end
-      alias_method :reset, :reset!
-
-    end # Eigenclass
-
-  end # Events
-
-end # Vedeu

data/test/lib/vedeu/colours/colour_translator_test.rb

@@ -1,169 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe ColourTranslator do
-
-    let(:described) { Vedeu::ColourTranslator }
-    let(:instance)  { described.new(colour) }
-    let(:colour)    { '#ff0000' }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@colour').must_equal(colour) }
-    end
-
-    describe 'accessors' do
-      it { instance.must_respond_to(:colour) }
-      it { instance.must_respond_to(:value) }
-    end
-
-    describe '.coerce' do
-      let(:_value) {}
-
-      subject { described.coerce(_value) }
-
-      context 'when the value is nil' do
-        it { subject.must_be_instance_of(Vedeu::ColourTranslator) }
-
-        it {
-          Vedeu::Background.coerce(_value).
-            must_be_instance_of(Vedeu::Background)
-        }
-        it { Vedeu::Background.coerce(_value).colour.must_equal('') }
-        it {
-          Vedeu::Foreground.coerce(_value).
-            must_be_instance_of(Vedeu::Foreground)
-        }
-        it { Vedeu::Foreground.coerce(_value).colour.must_equal('') }
-      end
-
-      context 'when the value is a Vedeu::Background' do
-        let(:_value) { Vedeu::Background.new }
-
-        it { subject.must_equal(_value) }
-      end
-
-      context 'when the value is a Vedeu::Foreground' do
-        let(:_value) { Vedeu::Foreground.new }
-
-        it { subject.must_equal(_value) }
-      end
-
-      context 'when the value is not a polymorphic Colour' do
-        let(:_value) { '#aadd00' }
-
-        it { subject.must_be_instance_of(Vedeu::ColourTranslator) }
-      end
-    end
-
-    describe '#empty?' do
-      subject { instance.empty? }
-
-      context 'when there is no colour' do
-        let(:colour) {}
-
-        it { subject.must_equal(true) }
-      end
-
-      context 'when there is a colour' do
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '#eql?' do
-      let(:other) { instance }
-
-      subject { instance.eql?(other) }
-
-      it { subject.must_equal(true) }
-
-      context 'when different to other' do
-        let(:other) { described.new('#ff00ff') }
-
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '#escape_sequence' do
-      subject { instance.escape_sequence }
-
-      context 'when no colour is given' do
-        let(:colour) {}
-
-        it { subject.must_equal('') }
-      end
-
-      context 'when the colour is a terminal named colour; e.g. :red' do
-        let(:colour) { :red }
-
-        it 'raises an exception since the subclasses Background and ' \
-           'Foreground handle this' do
-          proc { subject }.must_raise(Vedeu::NotImplemented)
-        end
-      end
-
-      context 'when the colour is a terminal numbered colour; e.g. 122' do
-        let(:colour) { 122 }
-
-        it 'raises an exception since the subclasses Background and ' \
-           'Foreground handle this' do
-          proc { subject }.must_raise(Vedeu::NotImplemented)
-        end
-      end
-
-      context 'when the colour is a HTML/CSS colour (RGB specified)' do
-        let(:colour) { '#ff0000' }
-
-        it 'raises an exception since the subclasses Background and ' \
-           'Foreground handle this' do
-          proc { subject }.must_raise(Vedeu::NotImplemented)
-        end
-      end
-
-      context 'when the colour is not supported' do
-        let(:colour) { [:not_supported] }
-
-        before { instance.stubs(:registered?).returns(false) }
-
-        it { subject.must_equal('') }
-      end
-    end
-
-    describe '#to_html' do
-      subject { instance.to_html }
-
-      context 'when no colour is given' do
-        let(:colour) {}
-
-        it { subject.must_equal('') }
-      end
-
-      context 'when the colour is a terminal named colour; e.g. :red' do
-        let(:colour) { :red }
-
-        it { subject.must_equal('') }
-      end
-
-      context 'when the colour is a terminal numbered colour; e.g. 122' do
-        let(:colour) { 122 }
-
-        it { subject.must_equal('') }
-      end
-
-      context 'when the colour is a HTML/CSS colour (RGB specified)' do
-        let(:colour) { '#ff0000' }
-
-        it { subject.must_equal('#ff0000') }
-      end
-
-      context 'when the colour is not supported' do
-        let(:colour) { [:not_supported] }
-
-        it { subject.must_equal('') }
-      end
-    end
-
-  end # ColourTranslator
-
-end # Vedeu

data/test/lib/vedeu/colours/colours_test.rb

@@ -1,93 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe Colours do
-
-    let(:described) { Vedeu::Colours }
-    let(:instance)  { described.new }
-
-    describe '#initialize' do
-      it { instance.must_be_instance_of(described) }
-      it { instance.instance_variable_get('@storage').must_equal({}) }
-    end
-
-    describe 'accessors' do
-      it { instance.must_respond_to(:storage) }
-    end
-
-    describe '#register' do
-      let(:colour)          { 'ff0000' }
-      let(:escape_sequence) { 'fake_escape_sequence' }
-
-      subject { instance.register(colour, escape_sequence) }
-
-      it { subject.must_equal('fake_escape_sequence') }
-    end
-
-    describe '#registered?' do
-      let(:colour) {}
-
-      subject { instance.registered?(colour) }
-
-      context 'when the colour is registered' do
-        let(:colour) { '#aa0000' }
-
-        before { instance.register(colour, 'fake_escape_sequence') }
-
-        it { subject.must_equal(true) }
-      end
-
-      context 'when the colour is not registered' do
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '#reset!' do
-      subject { instance.reset! }
-
-      it { subject.must_be_instance_of(Hash) }
-
-      it { subject.must_equal({}) }
-    end
-
-    describe '#retrieve' do
-      let(:colour) {}
-
-      subject { instance.retrieve(colour) }
-
-      context 'when the colour can be found' do
-        let(:colour) { '#bb0000' }
-
-        before { instance.register(colour, 'fake_escape_sequence') }
-
-        it { subject.must_equal('fake_escape_sequence') }
-      end
-
-      context 'when the colour cannot be found' do
-        it { subject.must_equal('') }
-      end
-    end
-
-    describe '#retrieve_or_register' do
-      let(:colour)          { '#cc0000' }
-      let(:escape_sequence) { 'escape_sequence' }
-
-      subject { instance.retrieve_or_register(colour, escape_sequence) }
-
-      context 'when the colour is registered' do
-        let(:colour) { '#cc0000' }
-
-        before { instance.register(colour, 'fake_escape_sequence') }
-
-        it { subject.must_equal('fake_escape_sequence') }
-      end
-
-      context 'when the colour is not registered' do
-        it { subject.must_equal('escape_sequence') }
-      end
-    end
-
-  end # Colours
-
-end # Vedeu

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

@@ -1,140 +0,0 @@
-require 'test_helper'
-
-module Vedeu
-
-  describe EventAliases do
-
-    let(:described) { Vedeu::EventAliases }
-
-    before { Vedeu::EventAliases.reset }
-    after  { Vedeu::Bindings.setup! }
-
-    describe '.add' do
-      let(:alias_name) { :alias_test }
-      let(:event_name) { :event_test }
-
-      subject { described.add(alias_name, event_name) }
-
-      it { described.must_respond_to(:bind_alias) }
-
-      context 'when the alias is already registered' do
-        before { Vedeu::EventAliases.add(:alias_test, :event_test) }
-
-        it { subject.must_equal([:event_test, :event_test]) }
-      end
-
-      context 'when the alias is not already registered' do
-        it { subject.must_equal([:event_test]) }
-      end
-    end
-
-    describe '.empty?' do
-      subject { described.empty? }
-
-      context 'when no aliases are registered' do
-        before { Vedeu::EventAliases.reset }
-
-        it { subject.must_equal(true) }
-      end
-
-      context 'when aliases are registered' do
-        before { Vedeu::EventAliases.add(:alias_test, :event_test) }
-
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '.find' do
-      # @todo Add more tests
-      # it { skip }
-    end
-
-    describe '.registered?' do
-      let(:alias_name) { :alias_test }
-
-      subject { described.registered?(alias_name) }
-
-      context 'when the alias is registered' do
-        before { Vedeu::EventAliases.add(:alias_test, :event_test) }
-
-        it { subject.must_equal(true) }
-      end
-
-      context 'when the alias is not registered' do
-        it { subject.must_equal(false) }
-      end
-    end
-
-    describe '.remove' do
-      let(:alias_name) { :alias_test }
-
-      before { Vedeu::EventAliases.reset }
-
-      subject { described.remove(alias_name) }
-
-      it { described.must_respond_to(:unbind_alias) }
-
-      context 'when no aliases are registered' do
-        it { subject.must_equal(false) }
-      end
-
-      context 'when the alias is not registered' do
-        before { Vedeu::EventAliases.add(:other_alias_test, :event_test) }
-
-        it { subject.must_equal(false) }
-      end
-
-      context 'when the alias is registered' do
-        before { Vedeu::EventAliases.add(:alias_test, :event_test) }
-
-        it { subject.must_equal({}) }
-      end
-    end
-
-    describe '.reset' do
-      subject { described.reset }
-
-      it { described.must_respond_to(:reset!) }
-
-      it { subject.must_equal({}) }
-    end
-
-    describe '.storage' do
-      before { Vedeu::EventAliases.reset }
-
-      subject { described.storage }
-
-      it { subject.must_equal({}) }
-    end
-
-    describe '.trigger' do
-      let(:alias_name) { :some_alias }
-      let(:args)       {}
-
-      subject { described.trigger(alias_name, *args) }
-
-      context 'when the alias name is registered' do
-        before do
-          Vedeu::Trigger.stubs(:trigger)
-
-          described.add(:some_alias, :some_event)
-          described.add(:some_alias, :other_event)
-        end
-
-        it {
-          Vedeu::Trigger.expects(:trigger).with(:some_event, nil)
-          Vedeu::Trigger.expects(:trigger).with(:other_event, nil)
-          subject
-        }
-      end
-
-      context 'when the alias name is not registered' do
-        let(:alias_name) {}
-
-        it { subject.must_equal([]) }
-      end
-    end
-
-  end # EventAliases
-
-end # Vedeu