vedeu 0.2.12 → 0.3.0

data/lib/vedeu/bindings.rb

@@ -0,0 +1,121 @@
+require 'vedeu/events/event'
+
+module Vedeu
+
+  module API
+
+    def_delegators Vedeu::Event, :bind, :trigger, :unbind
+
+  end
+
+  # Creates system events which when called provide a variety of core functions
+  # and behaviours.
+  #
+  # @note
+  #   Unbinding any of these events is likely to cause problems, so I would
+  #   advise leaving them alone. A safe rule: if the name starts with an
+  #   underscore, it's probably used by Vedeu internally.
+  #
+  # :nocov:
+  module Bindings
+
+    # System events needed by Vedeu to run.
+    Vedeu.bind(:_clear_)                   { Vedeu::Terminal.clear        }
+    Vedeu.bind(:_exit_)                    { Vedeu::Application.stop      }
+    Vedeu.bind(:_initialize_)              { Vedeu.trigger(:_refresh_)    }
+    Vedeu.bind(:_keypress_)                { |key| Vedeu.keypress(key)    }
+    Vedeu.bind(:_log_)                     { |msg| Vedeu.log(msg)         }
+    Vedeu.bind(:_mode_switch_)             { fail ModeSwitch              }
+    Vedeu.bind(:_resize_, { delay: 0.25 }) { Vedeu.resize                 }
+
+    # System events which when called will update the cursor visibility
+    # accordingly for the interface in focus, or the named interface. Also
+    # includes events to move the cursor in the direction specified; these will
+    # update the cursor position according to the interface in focus.
+    Vedeu.bind(:_cursor_hide_) do
+      ToggleCursor.hide(Vedeu.cursor)
+    end
+
+    Vedeu.bind(:_cursor_show_) do
+      ToggleCursor.show(Vedeu.cursor)
+    end
+
+    Vedeu.bind(:_cursor_hide_by_name_) do |name|
+      named = Vedeu.cursors.by_name(name)
+
+      ToggleCursor.hide(named)
+    end
+
+    Vedeu.bind(:_cursor_show_by_name_) do |name|
+      named = Vedeu.cursors.by_name(name)
+
+      ToggleCursor.show(named)
+    end
+
+    Vedeu.bind(:_cursor_down_) do
+      interface = Vedeu.interfaces.current
+
+      MoveCursor.down(Vedeu.cursor, interface)
+
+      Refresh.by_focus
+    end
+
+    Vedeu.bind(:_cursor_left_) do
+      interface = Vedeu.interfaces.current
+
+      MoveCursor.left(Vedeu.cursor, interface)
+
+      Refresh.by_focus
+    end
+
+    Vedeu.bind(:_cursor_right_) do
+      interface = Vedeu.interfaces.current
+
+      MoveCursor.right(Vedeu.cursor, interface)
+
+      Refresh.by_focus
+    end
+
+    Vedeu.bind(:_cursor_up_) do
+      interface = Vedeu.interfaces.current
+
+      MoveCursor.up(Vedeu.cursor, interface)
+
+      Refresh.by_focus
+    end
+
+    Vedeu.bind(:_cursor_origin_) do
+      interface = Vedeu.interfaces.current
+
+      MoveCursor.origin(Vedeu.cursor, interface)
+
+      Refresh.by_focus
+    end
+
+    # System events which when called will change which interface is currently
+    # focussed. When the interface is brought into focus, its cursor position
+    # and visibility is restored.
+    Vedeu.bind(:_focus_by_name_) { |name| Vedeu.focus_by_name(name) }
+    Vedeu.bind(:_focus_next_)    {        Vedeu.focus_next          }
+    Vedeu.bind(:_focus_prev_)    {        Vedeu.focus_previous      }
+
+    # System events which when called with the appropriate menu name will
+    # update the menu accordingly.
+    Vedeu.bind(:_menu_bottom_)   { |name| Vedeu.menus.find(name).bottom_item   }
+    Vedeu.bind(:_menu_current_)  { |name| Vedeu.menus.find(name).current_item  }
+    Vedeu.bind(:_menu_deselect_) { |name| Vedeu.menus.find(name).deselect_item }
+    Vedeu.bind(:_menu_items_)    { |name| Vedeu.menus.find(name).items         }
+    Vedeu.bind(:_menu_next_)     { |name| Vedeu.menus.find(name).next_item     }
+    Vedeu.bind(:_menu_prev_)     { |name| Vedeu.menus.find(name).prev_item     }
+    Vedeu.bind(:_menu_selected_) { |name| Vedeu.menus.find(name).selected_item }
+    Vedeu.bind(:_menu_select_)   { |name| Vedeu.menus.find(name).select_item   }
+    Vedeu.bind(:_menu_top_)      { |name| Vedeu.menus.find(name).top_item      }
+    Vedeu.bind(:_menu_view_)     { |name| Vedeu.menus.find(name).view          }
+
+    # System event to refresh all registered interfaces.
+    Vedeu.bind(:_refresh_) { Vedeu::Refresh.all }
+
+  end # Bindings
+  # :nocov:
+
+end # Vedeu

data/lib/vedeu/buffers/all.rb

@@ -0,0 +1,10 @@
+require 'vedeu/buffers/buffer'
+require 'vedeu/buffers/display_buffer'
+
+module Vedeu
+
+  def self.buffers
+    @_buffers ||= Vedeu::Repository.new(Vedeu::Buffer)
+  end
+
+end # Vedeu

data/lib/vedeu/{repositories/models → buffers}/buffer.rb

@@ -1,3 +1,5 @@
+require 'vedeu/models/model'
+
 module Vedeu
 
   # The Buffer object represents the states of display for an interface. The
@@ -12,49 +14,45 @@ module Vedeu
   #
   class Buffer
 
-    include Model
+    include Vedeu::Model
 
-    attr_reader :back, :front, :name, :previous
-    alias_method :current, :front
+    attr_accessor :back, :front, :previous
+    attr_reader   :name, :repository
 
     # Return a new instance of Buffer.
     #
-    # @param attributes [Hash]
+    # @param name [String] The name of the interface for which the buffer
+    #   belongs.
+    # @param back [Interface]
+    # @param front [Interface]
+    # @param previous [Interface]
     # @return [Buffer]
-    def initialize(attributes = {})
-      @attributes = defaults.merge(attributes)
-
-      @name     = @attributes[:name]
-      @back     = @attributes[:back]
-      @front    = @attributes[:front]
-      @previous = @attributes[:previous]
+    def initialize(name, back = nil, front = nil, previous = nil, repository = nil)
+      @name       = name
+      @back       = back
+      @front      = front
+      @previous   = previous
+      @repository = repository || Vedeu.buffers
     end
 
-    # Add the content to the back buffer, then update the repository. Returns
-    # boolean indicating that the repository was updated.
+    # Returns log friendly output.
     #
-    # @param content [Hash]
-    # @return [Boolean]
-    def add(content = {})
-      self.back = content
-
-      store
-
-      true
+    # @return [String]
+    def inspect
+      "<#{self.class.name} ( " \
+      "back?:#{content_for?(:back)} " \
+      "front?:#{content_for?(:front)} " \
+      "previous?:#{content_for?(:previous)} " \
+      ")>"
     end
 
-    # Return a boolean indicating content was swapped between buffers. It also
-    # resets the offsets (i.e. scroll/cursor position).
+    # Add the content to the back buffer, then update the repository. Returns
+    # boolean indicating that the repository was updated.
     #
+    # @param content [Interface]
     # @return [Boolean]
-    def swap
-      return false unless content_for?(:back)
-
-      # Offsets.update({ name: name })
-
-      self.previous = front
-      self.front    = back
-      self.back     = {}
+    def add(content)
+      @back = content
 
       store
 
@@ -70,14 +68,14 @@ module Vedeu
     #   buffer and display that.
     # - If there is no new content, and the front buffer is empty, display the
     #   'previous' buffer.
-    # - If the 'previous' buffer is empty, return an empty hash.
+    # - If the 'previous' buffer is empty, return an empty collection.
     #
     # @return [Array<Hash>]
     def content
       if content_for?(:back)
         swap
 
-        [clear_if_previous, front]
+        [front]
 
       elsif content_for?(:front)
         [front]
@@ -86,50 +84,35 @@ module Vedeu
         [previous]
 
       else
-        [{}]
+        []
 
       end
     end
 
-    private
-
-    attr_writer :back, :front, :previous
-
-    def clear_if_previous
-      if content_for?(:previous)
-        previous
+    # Return a boolean indicating content was swapped between buffers.
+    #
+    # @return [Boolean]
+    def swap
+      @previous = front
+      @front    = back
+      @back     = nil
 
-      else
-        {}
+      store
 
-      end
+      true
     end
 
+    private
+
     # Return a boolean indicating content presence on the buffer type.
     #
-    # @param buffer [Symbol] One of; :back, :current/:front or :previous.
+    # @param buffer [Symbol] One of; :back, :front or :previous.
     # @return [Boolean] Whether the buffer targetted has content.
     def content_for?(buffer)
-      public_send(buffer).any? do |k, v|
-        k == :lines && v && v.any?
-      end
-    end
+      return false if public_send(buffer).nil? ||
+                      public_send(buffer).content.empty?
 
-    # @return [Class] The repository class for this model.
-    def repository
-      Vedeu::Buffers
-    end
-
-    # Return the default attributes of a Buffer.
-    #
-    # @return [Hash]
-    def defaults
-      {
-        name:     '',
-        back:     {},
-        front:    {},
-        previous: {},
-      }
+      true
     end
 
   end # Buffer

data/lib/vedeu/buffers/display_buffer.rb

@@ -0,0 +1,118 @@
+require 'vedeu/repositories/repository'
+
+module Vedeu
+
+  # This module is included in Vedeu::Interface to provide means to store client
+  # application views created with {Vedeu.renders} or {Vedeu.views}.
+  #
+  module DisplayBuffer
+
+    include Vedeu::Common
+
+    # Store the view and immediate refresh it; causing to be pushed to the
+    # Terminal.
+    #
+    # @return [Interface]
+    def store_immediate
+      store_deferred
+
+      Vedeu::Refresh.by_name(name)
+
+      self
+    end
+
+    # Store the view if it has a name. This view will be shown next time the
+    # refresh event is triggered for the interface.
+    #
+    # @return [Interface]
+    def store_deferred
+      unless defined_value?(name)
+        fail InvalidSyntax, 'Cannot store an interface without a name.'
+      end
+
+      store_new_buffer
+
+      self
+    end
+
+    private
+
+    # Registers a set of buffers for the interface unless already registered,
+    # and also adds interface's name to list of focussable interfaces.
+    #
+    # @see Vedeu::Buffer
+    # @return [Interface]
+    def store_new_buffer
+      if Vedeu.buffers.registered?(name)
+        Vedeu.log("Updating buffer: '#{name}'")
+
+        Vedeu.buffers.find(name).add(self)
+
+      else
+        Vedeu.log("Registering buffer: '#{name}'")
+
+        Buffer.new(name, self).store
+
+      end
+
+      self
+    end
+
+    # Registers refresh events for the interface unless already registered.
+    #
+    # @return [Interface]
+    def store_refresh_events
+      options = { delay: delay }
+      event   = "_refresh_#{name}_".to_sym
+
+      unless Vedeu.events.registered?(event)
+        Vedeu.bind(event, options) { Vedeu::Refresh.by_name(name) }
+      end
+
+      unless group.nil? || group.empty?
+        event = "_refresh_group_#{group}_".to_sym
+
+        unless Vedeu.events.registered?(event)
+          Vedeu.bind(event, options) { Vedeu::Refresh.by_group(group) }
+        end
+      end
+
+      self
+    end
+
+    # Registers interface name in focus list unless already registered.
+    #
+    # @return [Interface]
+    def store_focusable
+      unless Vedeu.focusable.registered?(name)
+        Vedeu.focusable.add(name)
+      end
+
+      self
+    end
+
+    # Registers a new cursor for the interface unless already registered.
+    #
+    # @return [Interface]
+    def store_cursor
+      unless Vedeu.cursors.registered?(name)
+        Vedeu::Cursor.new({ name: name }).store
+      end
+
+      self
+    end
+
+    # Registers a new group for the interface unless already registered.
+    #
+    # @return [Interface]
+    def store_group
+      unless group.nil? || group.empty? || Vedeu.groups.registered?(group)
+        Vedeu::Group.new(name, group).store
+      end
+
+      self
+    end
+
+  end # DisplayBuffer
+
+end # Vedeu

data/lib/vedeu/configuration/all.rb

@@ -0,0 +1,6 @@
+require 'vedeu/configuration/cli'
+require 'vedeu/configuration/api'
+require 'vedeu/configuration/configuration'
+
+module Vedeu
+end # Vedeu

data/lib/vedeu/configuration/api.rb

@@ -1,3 +1,5 @@
+require 'vedeu/support/common'
+
 module Vedeu
 
   module Config
@@ -362,6 +364,6 @@ module Vedeu
 
     end # API
 
-  end # Configuration
+  end # Config
 
 end # Vedeu

data/lib/vedeu/configuration/cli.rb

@@ -1,3 +1,5 @@
+require 'optparse'
+
 module Vedeu
 
   module Config
@@ -125,6 +127,6 @@ module Vedeu
 
     end # CLI
 
-  end # Configuration
+  end # Config
 
 end # Vedeu

data/lib/vedeu/configuration/configuration.rb

@@ -1,5 +1,16 @@
+require 'singleton'
+
+require 'vedeu/support/common'
+require 'vedeu/configuration/api'
+require 'vedeu/configuration/cli'
+
 module Vedeu
 
+  # Namespace for the API configuration and CLI configuration classes.
+  #
+  module Config
+  end
+
   # Allows the customisation of Vedeu's behaviour through the configuration API
   # or command-line arguments.
   #
@@ -15,6 +26,8 @@ module Vedeu
 
     class << self
 
+      include Vedeu::Common
+
       # Configure Vedeu with sensible defaults. If the client application sets
       # options, override the defaults with those, and if command-line arguments
       # are provided at application invocation, override any options with the
@@ -22,11 +35,19 @@ module Vedeu
       #
       # @param args [Array]
       # @param block [Proc]
+      # @raise [InvalidSyntax] When the required block is not given.
       # @return [Hash]
       def configure(args = [], &block)
         instance.configure(args, &block)
       end
 
+      # Returns the configuration singleton.
+      #
+      # @return [Vedeu::Configuration]
+      def configuration
+        instance
+      end
+
       # Returns the chosen colour mode.
       #
       # @return [Fixnum]
@@ -94,7 +115,7 @@ module Vedeu
       end
       alias_method :trace, :trace?
 
-      # Vedeu's default system keys. Use {#system_keys}.
+      # Vedeu's default system keys. Use {Vedeu::Configuration.system_keys}.
       #
       # @return [Hash]
       def default_system_keys
@@ -142,7 +163,7 @@ module Vedeu
 
       @options.merge!(Config::CLI.configure(args)) if args.any?
 
-      @options
+      Configuration
     end
 
     # Reset the configuration to the default values.

data/lib/vedeu/cursor/all.rb

@@ -0,0 +1,23 @@
+require 'vedeu/repositories/repository'
+require 'vedeu/cursor/cursor'
+require 'vedeu/cursor/move_cursor'
+require 'vedeu/cursor/toggle_cursor'
+
+module Vedeu
+
+  class Cursors < Repository
+  end
+
+  extend self
+
+  # @return [Cursors]
+  def cursors
+    @_cursors ||= Vedeu::Cursors.new(Vedeu::Cursor)
+  end
+
+  # @return [Cursor|NilClass]
+  def cursor
+    cursors.current
+  end
+
+end # Vedeu

data/lib/vedeu/cursor/cursor.rb

@@ -0,0 +1,116 @@
+require 'vedeu/cursor/all'
+require 'vedeu/models/model'
+require 'vedeu/support/position'
+require 'vedeu/support/visible'
+
+module Vedeu
+
+  # Each interface has its own Cursor which maintains the position and
+  # visibility of the cursor within that interface.
+  #
+  # @api private
+  class Cursor
+
+    extend Forwardable
+
+    def_delegators :state, :visible?, :invisible?
+
+    include Vedeu::Model
+
+    attr_reader :attributes, :name, :ox, :oy, :repository, :state, :x, :y
+
+    # Provides a new instance of Cursor.
+    #
+    # @param attributes [Hash]
+    # @option attributes name [String] The name of the interface this cursor belongs to.
+    # @option attributes ox [Fixnum] The offset x coordinate.
+    # @option attributes oy [Fixnum] The offset y coordinate.
+    # @option attributes repository [Vedeu::Repository]
+    # @option attributes state [Boolean|Symbol] The visibility of the cursor, either +true+
+    #   or +false+, +:hide+ or +:show+.
+    # @option attributes x [Fixnum] The terminal x coordinate for the cursor.
+    # @option attributes y [Fixnum] The terminal y coordinate for the cursor.
+    #
+    # @return [Cursor]
+    def initialize(attributes = {})
+      # Hack because Repository#by_name creates Cursor objects with just a
+      # name.
+      if attributes.is_a?(String)
+        attributes = { name: attributes }
+      end
+
+      @attributes = defaults.merge(attributes)
+
+      @name       = @attributes.fetch(:name)
+      @ox         = @attributes.fetch(:ox)
+      @oy         = @attributes.fetch(:oy)
+      @repository = @attributes.fetch(:repository)
+      @state      = Vedeu::Visible.coerce(@attributes.fetch(:state))
+      @x          = @attributes.fetch(:x)
+      @y          = @attributes.fetch(:y)
+    end
+
+    # Returns log friendly output.
+    #
+    # @return [String]
+    def inspect
+      "<#{self.class.name} (#{@name}: x:#{@x} y:#{@y} ox:#{@ox} oy:#{@oy})>"
+    end
+
+    # Returns an escape sequence to position the cursor and set its visibility.
+    # When passed a block, will position the cursor, yield and return the
+    # original position.
+    #
+    # @param block [Proc]
+    # @return [String]
+    def to_s(&block)
+      if block_given?
+        [ sequence, yield, sequence ].join
+
+      else
+        sequence
+
+      end
+    end
+
+    private
+
+    # The default values for a new instance of this class.
+    #
+    # @return [Hash]
+    def defaults
+      {
+        name:       '',
+        ox:         0,
+        oy:         0,
+        repository: Vedeu.cursors,
+        state:      Vedeu::Visible.new(false),
+        x:          1,
+        y:          1,
+      }
+    end
+
+    # Returns the escape sequence to position the cursor and set its visibility.
+    #
+    # @return [String]
+    def sequence
+      [ position, visibility ].join
+    end
+
+    # Returns the escape sequence for setting the position of the cursor.
+    #
+    # @return [String]
+    def position
+      Vedeu::Position.new(y, x).to_s
+    end
+
+    # Returns the escape sequence for setting the visibility of the cursor.
+    #
+    # @return [String]
+    def visibility
+      state.cursor
+    end
+
+  end # Cursor
+
+end # Vedeu