vedeu 0.2.12 → 0.3.0

data/lib/vedeu/input/mapper.rb

@@ -0,0 +1,112 @@
+module Vedeu
+
+  class Mapper
+
+    # @param key [NilClass|String|Symbol]
+    # @param name [NilClass|String]
+    # @return [Boolean]
+    def self.keypress(key = nil, name = nil)
+      return false unless key
+
+      new(key, name).keypress
+    end
+
+    # @param key [NilClass|String|Symbol]
+    # @param name [NilClass|String]
+    # @return [Boolean]
+    def self.valid?(key = nil, name = nil)
+      return false unless key
+
+      new(key, name).valid?
+    end
+
+    # @param key [NilClass|String|Symbol]
+    # @param name [NilClass|String]
+    # @param repository [NilClass|Repository]
+    # @return [Mapper]
+    def initialize(key = nil, name = nil, repository = nil)
+      @key        = key
+      @name       = name
+      @repository = repository || Vedeu.keymaps
+    end
+
+    # @return [Boolean]
+    def keypress
+      return false unless key
+
+      return true if key_defined? && keymap.use(key)
+
+      return true if global_key? && keymap(global).use(key)
+
+      return true if system_key? && keymap(system).use(key)
+
+      false
+    end
+
+    # @return [Boolean]
+    def valid?
+      return false unless key
+
+      return false if key_defined?
+
+      return false if global_key?
+
+      return false if system_key?
+
+      true
+    end
+
+    private
+
+    attr_reader :key, :repository
+
+    # @return [Boolean]
+    def global_key?
+      key_defined?(global)
+    end
+
+    # @return [Boolean]
+    def system_key?
+      key_defined?(system)
+    end
+
+    # @param named [NilClass|String]
+    # @return [Boolean]
+    def key_defined?(named = name)
+      keymap?(named) && keymap(named).key_defined?(key)
+    end
+
+    # @param named [NilClass|String]
+    # @return [Keymap]
+    def keymap(named = name)
+      repository.find(named)
+    end
+
+    # @param named [NilClass|String]
+    # @return [Boolean]
+    def keymap?(named = name)
+      repository.registered?(named)
+    end
+
+    # With a name, we check the keymap with that name, otherwise we use the
+    # name of the interface currently in focus.
+    #
+    # @return [String|NilClass]
+    def name
+      @name || Vedeu.focus
+    end
+    alias_method :interface, :name
+
+    # @return [String]
+    def global
+      '_global_'
+    end
+
+    # @return [String]
+    def system
+      '_system_'
+    end
+
+  end # Mapper
+
+end # Vedeu

data/lib/vedeu/launcher.rb

@@ -46,14 +46,12 @@ module Vedeu
     def execute!
       $stdin, $stdout, $stderr = @stdin, @stdout, @stderr
 
-      Configuration.configure(argv)
-
-      Application.start
+      Application.start(configuration)
 
       @exit_code = 0
     rescue StandardError => uncaught_exception
       puts uncaught_exception.message
-      puts uncaught_exception.backtrace.join("\n")
+      puts uncaught_exception.backtrace.join("\n") if configuration.debug?
 
     ensure
       Vedeu.log("Exiting gracefully.")
@@ -66,6 +64,11 @@ module Vedeu
 
     attr_reader :argv
 
+    # @return []
+    def configuration
+      Configuration.configure(argv)
+    end
+
   end # Launcher
 
 end # Vedeu

data/lib/vedeu/models/all.rb

@@ -0,0 +1,12 @@
+require 'vedeu/models/collection'
+
+require 'vedeu/models/view/all'
+
+require 'vedeu/models/focus'
+require 'vedeu/models/geometry'
+require 'vedeu/models/group'
+require 'vedeu/models/menu'
+require 'vedeu/models/model'
+
+module Vedeu
+end # Vedeu

data/lib/vedeu/models/collection.rb

@@ -0,0 +1,71 @@
+module Vedeu
+
+  module Model
+
+    # Convert an Array into an object which has some meaning in the context it
+    # is being used.
+    #
+    # @private
+    class Collection
+
+      include Enumerable
+
+      attr_accessor :parent, :name
+
+      def self.coerce(collection = [], parent = nil, name = nil)
+        if collection.kind_of?(Vedeu::Model::Collection)
+          collection
+
+        elsif collection.is_a?(Array)
+          new(collection, parent, name)
+
+        else
+          new(Array(collection), parent, name)
+
+        end
+      end
+
+      def initialize(collection = [], parent = nil, name = nil)
+        @collection = collection
+        @parent     = parent
+        @name       = name
+      end
+
+      def [](value)
+        @collection[value]
+      end
+
+      # @return [Vedeu::Model::Collection]
+      def add(*other)
+        self.class.new(@collection += other, parent, name)
+      end
+      alias_method :<<, :add
+
+      def all
+        @collection
+      end
+
+      def each(&block)
+        @collection.each(&block)
+      end
+
+      # @return [Boolean]
+      def empty?
+        @collection.empty?
+      end
+
+      # @return [Fixnum]
+      def size
+        @collection.size
+      end
+
+      # @return [String]
+      def to_s
+        @collection.map(&:to_s).join
+      end
+
+    end # Collection
+
+  end # Model
+
+end # Vedeu

data/lib/vedeu/{repositories → models}/focus.rb

@@ -7,7 +7,6 @@ module Vedeu
   # @api private
   module Focus
 
-    include Repository
     extend self
 
     # Add an interface name to the focus list unless it is already registered.
@@ -17,48 +16,48 @@ module Vedeu
     #   collection, making that interface the currently focussed interface.
     # @return [Array] The collection of interface names.
     def add(name, focus = false)
-      return storage if registered?(name)
+      if registered?(name)
+        return storage unless focus
 
-      if focus
-        storage.unshift(name)
+        by_name(name)
+        storage
 
       else
-        storage.push(name)
+        Vedeu.log("Storing focus entry: '#{name}'")
 
+        if focus
+          storage.unshift(name)
+
+        else
+          storage.push(name)
+
+        end
       end
     end
 
-    # Focus an interface by name.
+    # Focus an interface by name. Used after defining an interface or interfaces
+    # to set the initially focussed interface.
     #
-    # @param name [String]
+    # @param name [String] The interface to focus; must be defined.
     # @raise [ModelNotFound] When the interface cannot be found.
-    # @return [String]
+    # @return [String] The name of the interface now in focus.
     def by_name(name)
-      fail ModelNotFound unless registered?(name)
+      fail ModelNotFound, "Cannot focus '#{name}' as this interface has not " \
+                          "been registered." unless registered?(name)
 
       storage.rotate!(storage.index(name))
 
       update
     end
+    alias_method :focus_by_name, :by_name
 
     # Return the interface currently focussed.
     #
-    # @raise [NoInterfacesDefined] When no interfaces are defined, we cannot
-    #   make one focussed.
     # @return [String]
     def current
-      fail NoInterfacesDefined if empty?
-
       storage.first
     end
-
-    # Return the cursor for the currently focussed interface. May be hidden.
-    #
-    # @return [String] The escape sequence to render the cursor as shown or
-    #   hidden.
-    def cursor
-      Interface.new(Interfaces.find(current)).cursor.to_s
-    end
+    alias_method :focus, :current
 
     # Returns a boolean indicating whether the named interface is focussed.
     #
@@ -67,6 +66,14 @@ module Vedeu
     def current?(name)
       current == name
     end
+    alias_method :focussed?, :current?
+
+    # Return a boolean indicating whether the storage is empty.
+    #
+    # @return [Boolean]
+    def empty?
+      storage.empty?
+    end
 
     # Put the next interface relative to the current interfaces in focus.
     #
@@ -77,6 +84,7 @@ module Vedeu
       update
     end
     alias_method :next, :next_item
+    alias_method :focus_next, :next_item
 
     # Put the previous interface relative to the current interface in focus.
     #
@@ -88,6 +96,7 @@ module Vedeu
     end
     alias_method :prev,     :prev_item
     alias_method :previous, :prev_item
+    alias_method :focus_previous, :prev_item
 
     # Refresh the interface in focus.
     #
@@ -96,6 +105,32 @@ module Vedeu
       Vedeu.trigger("_refresh_#{current}_".to_sym)
     end
 
+    # Returns a collection of the names of all the registered entities.
+    #
+    # @return [Array]
+    def registered
+      return [] if empty?
+
+      storage
+    end
+
+    # Returns a boolean indicating whether the named model is registered.
+    #
+    # @param name [String]
+    # @return [Boolean]
+    def registered?(name)
+      return false if empty?
+
+      storage.include?(name)
+    end
+
+    # Reset the repository.
+    #
+    # @return [Array|Hash|Set]
+    def reset
+      @_storage = in_memory
+    end
+
     private
 
     # Return the name of the interface in focus after triggering the refresh
@@ -112,6 +147,13 @@ module Vedeu
       current
     end
 
+    # Access to the storage for this repository.
+    #
+    # @return [Hash]
+    def storage
+      @_storage ||= in_memory
+    end
+
     # Returns an empty collection ready for the storing of interface names.
     #
     # @return [Array]