vedeu 0.2.12 → 0.3.0

data/lib/vedeu/output/all.rb

@@ -0,0 +1,8 @@
+require 'vedeu/output/border'
+require 'vedeu/output/compositor'
+require 'vedeu/output/output'
+require 'vedeu/output/viewport'
+require 'vedeu/output/writer'
+
+module Vedeu
+end # Vedeu

data/lib/vedeu/output/border.rb

@@ -0,0 +1,387 @@
+require 'vedeu/dsl/components/border'
+
+module Vedeu
+
+  # Provides the mechanism to decorate an interface with a border on all edges,
+  # or specific edges. The characters which are used for the border parts (e.g.
+  # the corners, verticals and horizontals) can be customised as can the colours
+  # and styles.
+  #
+  # @note Refer to UTF-8 U+2500 to U+257F for border characters. More details
+  #   can be found at: http://en.wikipedia.org/wiki/Box-drawing_character
+  #
+  class Border
+
+    include Vedeu::Model
+
+    attr_accessor :attributes
+
+    class << self
+
+      # @see Vedeu::Border#initialize
+      def build(attributes = {}, &block)
+        attributes = defaults.merge(attributes)
+
+        model = new(attributes[:interface], attributes)
+        model.deputy(attributes[:client]).instance_eval(&block) if block_given?
+        model
+      end
+
+      private
+
+      # The default values for a new instance of this class.
+      #
+      # @return [Hash]
+      def defaults
+        {
+          client:    nil,
+          interface: nil,
+        }
+      end
+
+    end
+
+    # Returns a new instance of Border.
+    #
+    # @param interface [Interface]
+    # @param attributes [Hash]
+    # @option attributes colour
+    # @option attributes style
+    # @option attributes enabled [Boolean]
+    # @option attributes show_bottom [Boolean]
+    # @option attributes show_left [Boolean]
+    # @option attributes show_right [Boolean]
+    # @option attributes show_top [Boolean]
+    # @option attributes horizontal [String]
+    # @option attributes vertical [String]
+    # @option attributes bottom_left [String]
+    # @option attributes bottom_right [String]
+    # @option attributes top_left [String]
+    # @option attributes top_right [String]
+    # @return [Border]
+    def initialize(interface, attributes = {})
+      @interface  = interface
+      @attributes = defaults.merge(attributes)
+      @colour     = Colour.coerce(@attributes[:colour])
+      @style      = Style.coerce(@attributes[:style])
+    end
+
+    # Returns the width of the interface determined by whether a left, right,
+    # both or neither borders are shown.
+    #
+    # @return [Fixnum]
+    def width
+      return interface.width unless enabled?
+
+      if left? && right?
+        interface.width - 2
+
+      elsif left? || right?
+        interface.width - 1
+
+      else
+        interface.width
+
+      end
+    end
+
+    # Returns the height of the interface determined by whether a top, bottom,
+    # both or neither borders are shown.
+    #
+    # @return [Fixnum]
+    def height
+      return interface.height unless enabled?
+
+      if top? && bottom?
+        interface.height - 2
+
+      elsif top? || bottom?
+        interface.height - 1
+
+      else
+        interface.height
+
+      end
+    end
+
+    # Returns the interface with border (if enabled) and the content for the
+    # interface.
+    #
+    # @return [Array<Array<String>>]
+    def render
+      out = []
+
+      out << top if top?
+
+      interface.viewport[0...height].each do |line|
+        out << [left, line[0...width], right].flatten
+      end
+
+      out << bottom if bottom?
+
+      out
+    end
+
+    # Set the border colour.
+    #
+    # @return []
+    def colour=(value)
+      @colour = Colour.coerce(value)
+    end
+
+    # Set the border style.
+    #
+    # @return []
+    def style=(value)
+      @style = Style.coerce(value)
+    end
+
+    # Returns a boolean indicating whether the border is to be shown for this
+    # interface.
+    #
+    # @return [Boolean]
+    def enabled?
+      attributes[:enabled]
+    end
+
+    # Returns a boolean indicating whether the bottom border is to be shown.
+    #
+    # @return [Boolean]
+    def bottom?
+      attributes[:show_bottom]
+    end
+
+    # Returns a boolean indicating whether the left border is to be shown.
+    #
+    # @return [Boolean]
+    def left?
+      attributes[:show_left]
+    end
+
+    # Returns a boolean indicating whether the right border is to be shown.
+    #
+    # @return [Boolean]
+    def right?
+      attributes[:show_right]
+    end
+
+    # Returns a boolean indicating whether the top border is to be shown.
+    #
+    # @return [Boolean]
+    def top?
+      attributes[:show_top]
+    end
+
+    # Returns a string representation of the border for the interface without
+    # content.
+    #
+    # @return [Boolean]
+    def to_s
+      render.map { |line| line.flatten.join }.join("\n")
+    end
+
+    private
+
+    attr_reader :colour, :interface, :style
+
+    # Renders the bottom border for the interface.
+    #
+    # @return [String]
+    def bottom
+      return [] unless bottom?
+
+      out = []
+
+      out << bottom_left
+      horizontal_border.each do |border|
+        out << border
+      end
+      out << bottom_right
+
+      out
+    end
+
+    # Renders the left border for the interface.
+    #
+    # @return [String]
+    def left
+      return '' unless left?
+
+      vertical_border
+    end
+
+    # Renders the right border for the interface.
+    #
+    # @return [String]
+    def right
+      return '' unless right?
+
+      vertical_border
+    end
+
+    # Renders the top border for the interface.
+    #
+    # @return [String]
+    def top
+      return [] unless top?
+
+      out = []
+      out << top_left
+      horizontal_border.each do |border|
+        out << border
+      end
+      out << top_right
+
+      out
+    end
+
+    # Renders the bottom left border character with escape codes for colour and
+    # style for the interface.
+    #
+    # @return [String]
+    def bottom_left
+      return '' unless left?
+
+      [*presentation, on, bl, off, *reset].join
+    end
+
+    # Renders the bottom right border character with escape codes for colour and
+    # style for the interface.
+    #
+    # @return [String]
+    def bottom_right
+      return '' unless right?
+
+      [*presentation, on, br, off, *reset].join
+    end
+
+    # Renders the top left border character with escape codes for colour and
+    # style for the interface.
+    #
+    # @return [String]
+    def top_left
+      return '' unless left?
+
+      [*presentation, on, tl, off, *reset].join
+    end
+
+    # Renders the top right border character with escape codes for colour and
+    # style for the interface.
+    #
+    # @return [String]
+    def top_right
+      return '' unless right?
+
+      [*presentation, on, tr, off, *reset].join
+    end
+
+    # Returns the horizontal border characters with colours and styles.
+    #
+    # @return [Array<String>]
+    def horizontal_border
+      [[*presentation, on, h, off, *reset].join] * width
+    end
+
+    # Returns the vertical border characters with colours and styles.
+    #
+    # @return [String]
+    def vertical_border
+      [*presentation, on, v, off, *reset].join
+    end
+
+    # Returns the horizontal border character.
+    #
+    # @return [String]
+    def h
+      attributes[:horizontal]
+    end
+
+    # Returns the vertical border character.
+    #
+    # @return [String]
+    def v
+      attributes[:vertical]
+    end
+
+    # Returns the top right border character.
+    #
+    # @return [String]
+    def tr
+      attributes[:top_right]
+    end
+
+    # Returns the top left border character.
+    #
+    # @return [String]
+    def tl
+      attributes[:top_left]
+    end
+
+    # Returns the bottom right border character.
+    #
+    # @return [String]
+    def br
+      attributes[:bottom_right]
+    end
+
+    # Returns the bottom left border character.
+    #
+    # @return [String]
+    def bl
+      attributes[:bottom_left]
+    end
+
+    # Returns the escape sequence to start a border.
+    #
+    # @return [String]
+    def on
+      "\e(0"
+    end
+
+    # Returns the escape sequence to end a border.
+    #
+    # @return [String]
+    def off
+      "\e(B"
+    end
+
+    # Returns the colour and styles for the border.
+    #
+    # @return [Array]
+    def presentation
+      [colour, style]
+    end
+
+    # Returns the colour and styles for the interface; effectively turning off
+    # the colours and styles for the border.
+    #
+    # @return [Array]
+    def reset
+      [interface.colour, interface.style]
+    end
+
+    # The default values for a new instance of this class.
+    #
+    # @return [Hash]
+    def defaults
+      {
+        enabled:      false,
+        show_bottom:  true,
+        show_left:    true,
+        show_right:   true,
+        show_top:     true,
+        bottom_right: "\x6A", # ┘
+        top_right:    "\x6B", # ┐
+        top_left:     "\x6C", # ┌
+        bottom_left:  "\x6D", # └
+        horizontal:   "\x71", # ─
+        colour:       {},
+        style:        [],
+        vertical:     "\x78", # │
+        interface:    nil,
+      }
+    end
+
+  end # Border
+
+end # Vedeu

data/lib/vedeu/output/compositor.rb

@@ -1,65 +1,76 @@
+require 'vedeu/support/common'
+
 module Vedeu
 
+  # Before the content of the buffer can be output to the terminal, if there are
+  # any changes to the geometry of the interface (stored in the buffer), then
+  # these need to be stored; replacing those already stored. This is our last
+  # chance to do this as the terminal may have resized, or the client
+  # application may have specified this this view should move to a new location.
+
   # Combines stored interface layout/geometry with an interface view/buffer
   # to create a single view to be sent to the terminal for output.
   #
   # @api private
   class Compositor
 
-    include Common
+    include Vedeu::Common
 
     # Convenience method to initialize a new Compositor and call its {#compose}
     # method.
     #
     # @return [Compositor]
     # @see #initialize
-    def self.compose(interface, buffer)
-      new(interface, buffer).compose
+    def self.compose(name)
+      new(name).compose
     end
 
     # Initialize a new Compositor.
     #
-    # @param interface [Hash] The attributes of the interface to be refreshed.
-    # @param buffer [Hash] The atttributes of the buffer to refresh the
-    #   interface with.
+    # @param name [String] The name of the buffer.
     # @return [Compositor]
-    def initialize(interface, buffer)
-      @interface = interface
-      @buffer    = buffer
+    def initialize(name)
+      @name = name
     end
 
-    # Return a new instance of Interface built by combining the buffer content
-    # attributes with the stored interface attributes.
+    # @todo What do we do about resizing terminals. I don't want to overwrite
+    # the stored geometry and when the terminal returns to original size not also
+    # return the interface back to its originally prescribed dimensions.
+    #
+    # @note
+    # If the buffer has geometry stored, we should check whether this is different
+    # to the geometries repository- the client application is wanting to resize
+    # or move the interface.
+    #
+    # If it is different, overwrite the old geometry with the new.
     #
-    # @return [Array<Hash>] The updated interface attributes.
+    # If the buffer does not have geometry stored, retrieve the geometry for this
+    # interface from the geometries repository so we can draw this buffer in the
+    # correct place.
+    #
+    # @return [Array<Interface>]
     def compose
-      buffer.content.each do |content|
-        change_geometry(content)
-
-        interface[:lines] = content[:lines]
-        change_colour(content)
-        change_style(content)
+      buffer.map do |view|
+        view.border   = interface.border   unless view.border
+        view.colour   = interface.colour   unless view.colour
+        view.style    = interface.style    unless view.style
+        view.geometry = interface.geometry unless view.geometry
 
-        Output.render(Interface.new(interface))
+        Output.render(view)
       end
     end
 
     private
 
-    attr_reader :interface, :buffer
-
-    def change_colour(content)
-      interface[:colour] = content[:colour] if defined_value?(content[:colour])
-    end
+    attr_reader :name
 
-    def change_geometry(content)
-      content[:geometry].each do |k, v|
-        interface[:geometry][k] = v if defined_value?(k)
-      end if defined_value?(content[:geometry])
+    def buffer
+      Vedeu.buffers.find(name).content
     end
 
-    def change_style(content)
-      interface[:style] = content[:style] if defined_value?(content[:style])
+    # @return [Interface]
+    def interface
+      @interface ||= Vedeu.interfaces.find(name)
     end
 
   end # Compositor

data/lib/vedeu/output/output.rb

@@ -1,5 +1,7 @@
 module Vedeu
 
+  # Sends the interface to the terminal or output device.
+  #
   class Output
 
     # Writes content (the provided interface object with associated lines,
@@ -23,7 +25,7 @@ module Vedeu
     #
     # @return [Array]
     def render
-      Terminal.output(view, Focus.cursor)
+      Terminal.output(view, interface.cursor.to_s)
     end
 
     private
@@ -38,21 +40,11 @@ module Vedeu
     def clear
       Vedeu.log("Clearing view: '#{interface.name}'")
 
-      rows.inject([colours]) do |line, index|
+      interface.height.times.inject([interface.colour]) do |line, index|
         line << interface.origin(index) { ' ' * interface.width }
       end.join
     end
 
-    # @return [String]
-    def colours
-      interface.colour.to_s
-    end
-
-    # @return [Enumerator]
-    def rows
-      interface.height.times
-    end
-
     # Produces a single string which contains all content and escape sequences
     # required to render this interface in the terminal window.
     #
@@ -62,10 +54,11 @@ module Vedeu
 
       Vedeu.log("Rendering view: '#{interface.name}'")
 
-      interface.border.to_viewport.each_with_index do |line, index|
+      interface.render.each_with_index do |line, index|
         out << interface.origin(index)
         out << line.join
       end
+
       out.join
     end