vedeu 0.6.1 → 0.6.2

data/lib/vedeu/dsl/shared.rb

@@ -20,11 +20,11 @@ module Vedeu
       #   when we define the interface or view, setting it here is just
       #   mirroring functionality of {Vedeu::DSL::Border.border}.
       # @param block [Proc]
-      # @raise [Vedeu::InvalidSyntax] The required block was not given.
+      # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
       # @return [Vedeu::Border]
       # @see Vedeu::DSL::Border
       def border(name = nil, &block)
-        fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+        fail Vedeu::Error::InvalidSyntax, 'block not given' unless block_given?
 
         model_name = name ? name : model.name
 
@@ -63,11 +63,11 @@ module Vedeu
       #   when we define the interface or view, setting it here is just
       #   mirroring functionality of {Vedeu::DSL::Geometry.geometry}.
       # @param block [Proc]
-      # @raise [Vedeu::InvalidSyntax] The required block was not given.
+      # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
       # @return [Vedeu::Geometry]
       # @see Vedeu::DSL::Geometry
       def geometry(name = nil, &block)
-        fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+        fail Vedeu::Error::InvalidSyntax, 'block not given' unless block_given?
 
         model_name = name ? name : model.name
 

data/lib/vedeu/dsl/stream.rb

@@ -21,10 +21,10 @@ module Vedeu
       end
 
       # @param block [Proc]
-      # @raise [Vedeu::InvalidSyntax] The required block was not given.
+      # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
       # @return [void]
       def stream(&block)
-        fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+        fail Vedeu::Error::InvalidSyntax, 'block not given' unless block_given?
 
         model.add(model.class.build(attributes, &block))
       end

data/lib/vedeu/dsl/text.rb

@@ -58,11 +58,17 @@ module Vedeu
 
         Vedeu::Text.add(value, options)
       end
-      alias_method :align,  :text
-      alias_method :center, :text
-      alias_method :centre, :text
-      alias_method :left,   :text
-      alias_method :right,  :text
+      alias_method :text=,   :text
+      alias_method :align,   :text
+      alias_method :center,  :text
+      alias_method :centre,  :text
+      alias_method :left,    :text
+      alias_method :right,   :text
+      alias_method :align=,  :text
+      alias_method :center=, :text
+      alias_method :centre=, :text
+      alias_method :left=,   :text
+      alias_method :right=,  :text
 
     end # Text
 

data/lib/vedeu/dsl/use.rb

@@ -28,8 +28,8 @@ module Vedeu
       #
       # @param name [String] The name of the model with the value you wish to
       #   use.
-      # @raise [Vedeu::ModelNotFound|Vedeu::NoMethodError] The model or
-      #   attribute cannot be found.
+      # @raise [Vedeu::Error::ModelNotFound|Vedeu::Error::NoMethodError]
+      #   The model or attribute cannot be found.
       # @return [void] The stored model.
       def use(name)
         model.repository.by_name(name)

data/lib/vedeu/dsl/view.rb

@@ -126,10 +126,11 @@ module Vedeu
         #
         # @param block [Proc] The directives you wish to send to render.
         #   Typically includes `view` with associated sub-directives.
-        # @raise [Vedeu::InvalidSyntax] The required block was not given.
+        # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
         # @return [Array<View>]
         def renders(&block)
-          fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+          fail Vedeu::Error::InvalidSyntax,
+               'block not given' unless block_given?
 
           store(:store_immediate, &block)
         end
@@ -170,10 +171,11 @@ module Vedeu
         #
         # @param block [Proc] The directives you wish to send to render.
         #   Typically includes `view` with associated sub-directives.
-        # @raise [Vedeu::InvalidSyntax] The required block was not given.
+        # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
         # @return [Array<View>]
         def views(&block)
-          fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+          fail Vedeu::Error::InvalidSyntax,
+               'block not given' unless block_given?
 
           store(:store_deferred, &block)
         end
@@ -241,10 +243,10 @@ module Vedeu
       #     end
       #   end
       #
-      # @raise [Vedeu::InvalidSyntax] The required block was not given.
+      # @raise [Vedeu::Error::InvalidSyntax] The required block was not given.
       # @return [Vedeu::Views::Line]
       def lines(&block)
-        fail Vedeu::InvalidSyntax, 'block not given' unless block_given?
+        fail Vedeu::Error::InvalidSyntax, 'block not given' unless block_given?
 
         model.add(model.member.build(attributes, &block))
       end

data/lib/vedeu/events/aliases.rb

@@ -0,0 +1,91 @@
+module Vedeu
+
+  module Events
+
+    # Allows the storing of event aliases. Each alias can contain multiple event
+    # names.
+    #
+    module Aliases
+
+      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::Events::Trigger.trigger(event_name, *args)
+        end
+      end
+
+      private
+
+      # @return [Hash<Symbol => Array<Symbol>>]
+      def in_memory
+        Hash.new { |hash, key| hash[key] = [] }
+      end
+
+    end # Aliases
+
+  end # Events
+
+end # Vedeu

data/lib/vedeu/events/all.rb

@@ -0,0 +1,15 @@
+module Vedeu
+
+  # Provides event driven control to Vedeu.
+  #
+  module Events
+
+  end # Events
+
+end # Vedeu
+
+require 'vedeu/events/collection'
+require 'vedeu/events/aliases'
+require 'vedeu/events/trigger'
+require 'vedeu/events/repository'
+require 'vedeu/events/event'

data/lib/vedeu/events/collection.rb

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

data/lib/vedeu/events/event.rb

@@ -1,282 +1,287 @@
 module Vedeu
 
-  # Contains all the logic of an event. Handles debouncing and throttling.
-  #
-  # Vedeu provides an event mechanism to facilitate the functionality of your
-  # application. The events are either Vedeu defined, ie. system events or user
-  # defined, ie. user events. User events allow you to orchestrate behaviour
-  # within your application, ie. the user presses a specific key, you trigger an
-  # event to make something happen. Eg. pressing 'p' instructs the player to
-  # play.
-  #
-  # Events described here assume that you have either included Vedeu in your
-  # class:
-  #
-  #   class SomeClassInYourApplication
-  #     include Vedeu
-  #
-  #     bind :event_name do |arg1, arg2|
-  #       # Things that should happen when the event is triggered; these can be
-  #       # method calls or the triggering of another event or events.
-  #     end
-  #
-  # or, you are prepared to use the `Vedeu` prefix:
-  #
-  #   class SomeClassInYourApplication
-  #     Vedeu.bind(:event_name) do
-  #       # Not all events you define will have arguments; like methods.
-  #       :do_stuff
-  #     end
-  #
-  class Event
-
-    include Vedeu::Model
-
-    class << self
-
-      # Register an event by name with optional delay (throttling) which when
-      # triggered will execute the code contained within the passed block.
-      #
-      # @param name [Symbol] The name of the event to be triggered later.
-      # @param options [Hash] The options to register the event with.
-      # @option options :delay [Fixnum|Float] Limits the execution of the
-      #   triggered event to only execute when first triggered, with subsequent
-      #   triggering being ignored until the delay has expired.
-      # @option options :debounce [Fixnum|Float] Limits the execution of the
-      #   triggered event to only execute once the debounce has expired.
-      #   Subsequent triggers before debounce expiry are ignored.
-      # @param block [Proc] The event to be executed when triggered. This block
-      #   could be a method call, or the triggering of another event, or
-      #   sequence of either/both.
-      #
-      # @example
-      #   Vedeu.bind :my_event do |some, args|
-      #     # ... some code here ...
-      #
-      #     Vedeu.trigger(:my_other_event)
-      #   end
-      #
-      #   T = Triggered, X = Executed, i = Ignored.
-      #
-      #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6...
-      #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T
-      #   .X...i...i...i...i...X...i...i...i...i...X...i...i...i...i...i...i...i
-      #
-      #   Vedeu.bind(:my_delayed_event, { delay: 0.5 })
-      #     # ... some code here ...
-      #   end
-      #
-      #   T = Triggered, X = Executed, i = Ignored.
-      #
-      #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6...
-      #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T
-      #   .i...i...i...i...i...i...i...X...i...i...i...i...i...i...X...i...i...i
-      #
-      #   Vedeu.bind(:my_debounced_event, { debounce: 0.7 })
-      #     # ... some code here ...
-      #   end
-      #
-      # @return [TrueClass]
-      def bind(name, options = {}, &block)
-        Vedeu.log(type: :event, message: "Binding: '#{name.inspect}'")
-
-        new(name, block, options).bind
-      end
-      alias_method :event, :bind
-      alias_method :register, :bind
+  module Events
 
-      # Return a boolean indicating whether the named event is registered.
-      #
-      # @example
-      #   Vedeu.bound?(:some_event)
+    # Contains all the logic of an event. Handles debouncing and throttling.
+    #
+    # Vedeu provides an event mechanism to facilitate the functionality of your
+    # application. The events are either Vedeu defined, ie. system events or
+    # user defined, ie. user events. User events allow you to orchestrate
+    # behaviour within your application, ie. the user presses a specific key,
+    # you trigger an event to make something happen. Eg. pressing 'p' instructs
+    # the player to play.
+    #
+    # Events described here assume that you have either included Vedeu in your
+    # class:
+    #
+    #   class SomeClassInYourApplication
+    #     include Vedeu
+    #
+    #     bind :event_name do |arg1, arg2|
+    #       # Things that should happen when the event is triggered; these can
+    #       # be method calls or the triggering of another event or events.
+    #     end
+    #
+    # or, you are prepared to use the `Vedeu` prefix:
+    #
+    #   class SomeClassInYourApplication
+    #     Vedeu.bind(:event_name) do
+    #       # Not all events you define will have arguments; like methods.
+    #       :do_stuff
+    #     end
+    #
+    class Event
+
+      include Vedeu::Model
+
+      class << self
+
+        # Register an event by name with optional delay (throttling) which when
+        # triggered will execute the code contained within the passed block.
+        #
+        # @param name [Symbol] The name of the event to be triggered later.
+        # @param options [Hash] The options to register the event with.
+        # @option options :delay [Fixnum|Float] Limits the execution of the
+        #   triggered event to only execute when first triggered, with
+        #   subsequent triggering being ignored until the delay has expired.
+        # @option options :debounce [Fixnum|Float] Limits the execution of the
+        #   triggered event to only execute once the debounce has expired.
+        #   Subsequent triggers before debounce expiry are ignored.
+        # @param block [Proc] The event to be executed when triggered. This
+        #   block could be a method call, or the triggering of another event, or
+        #   sequence of either/both.
+        #
+        # @example
+        #   Vedeu.bind :my_event do |some, args|
+        #     # ... some code here ...
+        #
+        #     Vedeu.trigger(:my_other_event)
+        #   end
+        #
+        #   T = Triggered, X = Executed, i = Ignored.
+        #
+        #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6.
+        #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T..
+        #   .X...i...i...i...i...X...i...i...i...i...X...i...i...i...i...i...i..
+        #
+        #   Vedeu.bind(:my_delayed_event, { delay: 0.5 })
+        #     # ... some code here ...
+        #   end
+        #
+        #   T = Triggered, X = Executed, i = Ignored.
+        #
+        #   0.0.....0.2.....0.4.....0.6.....0.8.....1.0.....1.2.....1.4.....1.6.
+        #   .T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T...T..
+        #   .i...i...i...i...i...i...i...X...i...i...i...i...i...i...X...i...i..
+        #
+        #   Vedeu.bind(:my_debounced_event, { debounce: 0.7 })
+        #     # ... some code here ...
+        #   end
+        #
+        # @return [TrueClass]
+        def bind(name, options = {}, &block)
+          Vedeu.log(type: :event, message: "Binding: '#{name.inspect}'")
+
+          new(name, block, options).bind
+        end
+        alias_method :event, :bind
+        alias_method :register, :bind
+
+        # Return a boolean indicating whether the named event is registered.
+        #
+        # @example
+        #   Vedeu.bound?(:some_event)
+        #
+        # @param name [Symbol]
+        # @return [Boolean]
+        def bound?(name)
+          Vedeu.events.registered?(name) ||
+            Vedeu::Events::Aliases.registered?(name)
+        end
+
+        # Unbind events from a named handler.
+        #
+        # Removes all events associated with the given name.
+        #
+        # @example
+        #   Vedeu.unbind(:some_event)
+        #
+        # @param name [Symbol]
+        # @return [Boolean]
+        def unbind(name)
+          return false unless Vedeu.bound?(name)
+
+          Vedeu.log(type: :event, message: "Unbinding: '#{name.inspect}'")
+
+          Vedeu.events.remove(name)
+
+          true
+        end
+
+        extend Forwardable
+
+        def_delegators Vedeu::Events::Trigger, :trigger
+
+      end # Eigenclass
+
+      # Returns a new instance of Vedeu::Events::Event.
       #
-      # @param name [Symbol]
-      # @return [Boolean]
-      def bound?(name)
-        Vedeu.events.registered?(name) || Vedeu::EventAliases.registered?(name)
+      # @param (see Vedeu::Events::Event.bind)
+      # @return [Vedeu::Events::Event]
+      def initialize(name, closure, options = {})
+        @name         = name
+        @options      = options
+        @closure      = closure
+        @deadline     = 0
+        @executed_at  = 0
+        @now          = 0
+        @repository   = Vedeu.events
       end
 
-      # Unbind events from a named handler.
-      #
-      # Removes all events associated with the given name.
-      #
-      # @example
-      #   Vedeu.unbind(:some_event)
-      #
-      # @param name [Symbol]
-      # @return [Boolean]
-      def unbind(name)
-        return false unless Vedeu.bound?(name)
+      # @see Vedeu::Events::Event.bind
+      def bind
+        if repository.registered?(name)
+          new_collection = repository.find(name).add(self)
 
-        Vedeu.log(type: :event, message: "Unbinding: '#{name.inspect}'")
+        else
+          new_collection = Vedeu::Events::Collection.new([self], nil, name)
 
-        Vedeu.events.remove(name)
+        end
+
+        repository.store(new_collection)
 
         true
       end
 
-      extend Forwardable
-
-      def_delegators Vedeu::Trigger, :trigger
-
-    end # Eigenclass
+      # Triggers the event based on debouncing and throttling conditions.
+      #
+      # @param args [Array]
+      # @return [void]
+      def trigger(*args)
+        return execute(*args) unless debouncing? || throttling?
 
-    # Returns a new instance of Vedeu::Event.
-    #
-    # @param (see Vedeu::Event.bind)
-    # @return [Vedeu::Event]
-    def initialize(name, closure, options = {})
-      @name         = name
-      @options      = options
-      @closure      = closure
-      @deadline     = 0
-      @executed_at  = 0
-      @now          = 0
-      @repository   = Vedeu.events
-    end
-
-    # @see Vedeu::Event.bind
-    def bind
-      if repository.registered?(name)
-        new_collection = repository.find(name).add(self)
-
-      else
-        new_collection = Vedeu::EventCollection.new([self], nil, name)
+        return execute(*args) if debouncing? && debounce_expired?
 
+        return execute(*args) if throttling? && throttle_expired?
       end
 
-      repository.store(new_collection)
-
-      true
-    end
+      protected
 
-    # Triggers the event based on debouncing and throttling conditions.
-    #
-    # @param args [Array]
-    # @return [void]
-    def trigger(*args)
-      return execute(*args) unless debouncing? || throttling?
-
-      return execute(*args) if debouncing? && debounce_expired?
+      # @!attribute [r] closure
+      # @return [String]
+      attr_reader :closure
 
-      return execute(*args) if throttling? && throttle_expired?
-    end
+      # @!attribute [r] name
+      # @return [String]
+      attr_reader :name
 
-    protected
+      private
 
-    # @!attribute [r] closure
-    # @return [String]
-    attr_reader :closure
+      # Execute the code stored in the event closure.
+      #
+      # @param args [void]
+      # @return [void]
+      def execute(*args)
+        @deadline    = 0    # reset deadline
+        @executed_at = @now # set execution time to now
+        @now         = 0    # reset now
 
-    # @!attribute [r] name
-    # @return [String]
-    attr_reader :name
+        message = "Triggering: '#{name.inspect}'"
+        message << " with '#{args.inspect}'" if args.any?
 
-    private
+        Vedeu.log(type: :event, message: message)
 
-    # Execute the code stored in the event closure.
-    #
-    # @param args [void]
-    # @return [void]
-    def execute(*args)
-      @deadline    = 0    # reset deadline
-      @executed_at = @now # set execution time to now
-      @now         = 0    # reset now
-
-      message = "Triggering: '#{name.inspect}'"
-      message << " with '#{args.inspect}'" if args.any?
+        closure.call(*args)
+      end
 
-      Vedeu.log(type: :event, message: message)
+      # Returns a boolean indicating whether throttling is required for this
+      # event. Setting the delay option to any value greater than 0 will enable
+      # throttling.
+      #
+      # @return [Boolean]
+      def throttling?
+        @now = Time.now.to_f
 
-      closure.call(*args)
-    end
+        options[:delay] > 0
+      end
 
-    # Returns a boolean indicating whether throttling is required for this
-    # event. Setting the delay option to any value greater than 0 will enable
-    # throttling.
-    #
-    # @return [Boolean]
-    def throttling?
-      @now = Time.now.to_f
+      # Returns a boolean indicating whether the throttle has expired.
+      #
+      # @return [Boolean]
+      def throttle_expired?
+        return true if (@now - @executed_at) > delay
 
-      options[:delay] > 0
-    end
+        Vedeu.log(type: :event, message: "Throttling: '#{name.inspect}'")
 
-    # Returns a boolean indicating whether the throttle has expired.
-    #
-    # @return [Boolean]
-    def throttle_expired?
-      return true if (@now - @executed_at) > delay
+        false
+      end
 
-      Vedeu.log(type: :event, message: "Throttling: '#{name.inspect}'")
+      # Returns a boolean indicating whether debouncing is required for this
+      # event. Setting the debounce option to any value greater than 0 will
+      # enable debouncing.
+      # Sets the deadline for when this event can be executed to a point in the
+      # future determined by the amount of debounce time left.
+      #
+      # @return [Boolean]
+      def debouncing?
+        @now = Time.now.to_f
 
-      false
-    end
+        @deadline = @now + debounce unless deadline?
 
-    # Returns a boolean indicating whether debouncing is required for this
-    # event. Setting the debounce option to any value greater than 0 will
-    # enable debouncing.
-    # Sets the deadline for when this event can be executed to a point in the
-    # future determined by the amount of debounce time left.
-    #
-    # @return [Boolean]
-    def debouncing?
-      @now = Time.now.to_f
+        options[:debounce] > 0
+      end
 
-      @deadline = @now + debounce unless deadline?
+      # Returns a boolean indicating whether the debounce has expired.
+      #
+      # @return [Boolean]
+      def debounce_expired?
+        return true if (@executed_at = @now) > @deadline
 
-      options[:debounce] > 0
-    end
+        Vedeu.log(type: :event, message: "Debouncing: '#{name.inspect}'")
 
-    # Returns a boolean indicating whether the debounce has expired.
-    #
-    # @return [Boolean]
-    def debounce_expired?
-      return true if (@executed_at = @now) > @deadline
+        false
+      end
 
-      Vedeu.log(type: :event, message: "Debouncing: '#{name.inspect}'")
+      # Returns a boolean indicating whether this event has a deadline.
+      #
+      # @return [Boolean]
+      def deadline?
+        @deadline > 0
+      end
 
-      false
-    end
+      # Return the amount of time in seconds to debounce the event by.
+      #
+      # @return [Fixnum|Float]
+      def debounce
+        options[:debounce] || defaults[:debounce]
+      end
 
-    # Returns a boolean indicating whether this event has a deadline.
-    #
-    # @return [Boolean]
-    def deadline?
-      @deadline > 0
-    end
+      # Return the amount of time in seconds to throttle the event by.
+      #
+      # @return [Fixnum|Float]
+      def delay
+        options[:delay] || defaults[:delay]
+      end
 
-    # Return the amount of time in seconds to debounce the event by.
-    #
-    # @return [Fixnum|Float]
-    def debounce
-      options[:debounce] || defaults[:debounce]
-    end
+      # Combines the options provided at instantiation with the default values.
+      #
+      # @return [Hash]
+      def options
+        defaults.merge!(@options)
+      end
 
-    # Return the amount of time in seconds to throttle the event by.
-    #
-    # @return [Fixnum|Float]
-    def delay
-      options[:delay] || defaults[:delay]
-    end
+      # The default values for a new instance of this class.
+      #
+      # @return [Hash]
+      def defaults
+        {
+          delay:      0.0,
+          debounce:   0.0,
+        }
+      end
 
-    # Combines the options provided at instantiation with the default values.
-    #
-    # @return [Hash]
-    def options
-      defaults.merge!(@options)
-    end
+    end # Event
 
-    # The default values for a new instance of this class.
-    #
-    # @return [Hash]
-    def defaults
-      {
-        delay:      0.0,
-        debounce:   0.0,
-      }
-    end
-
-  end # Event
+  end # Events
 
 end # Vedeu