vedeu 0.4.13 → 0.4.14

data/lib/vedeu/output/border.rb

@@ -136,28 +136,28 @@ module Vedeu
     def bx
       bo = (enabled? && left?) ? 1 : 0
 
-      interface.x + bo
+      geometry.x + bo
     end
 
     # @return [Fixnum]
     def bxn
       bo = (enabled? && right?) ? 1 : 0
 
-      interface.xn - bo
+      geometry.xn - bo
     end
 
     # @return [Fixnum]
     def by
       bo = (enabled? && top?) ? 1 : 0
 
-      interface.y + bo
+      geometry.y + bo
     end
 
     # @return [Fixnum]
     def byn
       bo = (enabled? && bottom?) ? 1 : 0
 
-      interface.yn - bo
+      geometry.yn - bo
     end
 
     # Returns the width of the interface determined by whether a left, right,
@@ -190,6 +190,7 @@ module Vedeu
 
     # @return [Array<Array<Vedeu::Char>>]
     def render
+      return [] unless interface.visible?
       return [] unless enabled?
 
       out = [top, bottom]
@@ -262,20 +263,8 @@ module Vedeu
       out = []
       out << border(send(prefix_left), prefix_left) if left?
 
-      if prefix == 'top' && defined_value?(title)
-        title_out = []
-        width.times do |ix|
-          title_out << border(horizontal, prefix_horizontal, nil, ix)
-        end
-
-        truncate = title.chomp.slice(0..(width - 5))
-        pad      = truncate.center(truncate.size + 2).chars
-        out << title_out.each_with_index do |b, i|
-          if i >= 1 && i <= pad.size
-            b.border = nil
-            b.value  = pad[(i - 1)]
-          end
-        end
+      if prefix == 'top' && title?
+        out << titlebar
 
       else
         width.times do |ix|
@@ -288,18 +277,90 @@ module Vedeu
       out
     end
 
+    # @return [Array<Vedeu::Char>]
+    def horizontal_border
+      width.times.inject([]) do |a, ix|
+        a << border(horizontal, :top_horizontal, nil, ix)
+        a
+      end
+    end
+
+    # From the second element of {#title_characters} remove the border from each
+    # {#horizontal_border} Vedeu::Char, and add the title character.
+    #
+    # @return [Array<Vedeu::Char>]
+    def titlebar
+      horizontal_border.each_with_index do |char, index|
+        if index >= 1 && index <= title_characters.size
+          char.border = nil
+          char.value  = title_characters[(index - 1)]
+        end
+      end
+    end
+
+    # @return [Array<String>]
+    def title_characters
+      @title_characters ||= padded_title.chars
+    end
+
+    # Pads the title with a single whitespace either side.
+    #
+    # @example
+    #   title = 'Truncated!'
+    #   width = 20
+    #   # => ' Truncated! '
+    #
+    #   width = 10
+    #   # => ' Trunca '
+    #
+    # @return [String]
+    # @see #truncated_title
+    def padded_title
+      truncated_title.center(truncated_title.size + 2)
+    end
+
+    # Truncates the title to the width of the interface, minus characters needed
+    # to ensure there is at least a single character of horizontal border and a
+    # whitespace on either side of the title.
+    #
+    # @example
+    #   title = 'Truncated!'
+    #   width = 20
+    #   # => 'Truncated!'
+    #
+    #   width = 10
+    #   # => 'Trunca'
+    #
+    # @return [String]
+    def truncated_title
+      title.chomp.slice(0..(width - 5))
+    end
+
+    # Return boolean indicating whether this border has a non-empty title.
+    #
+    # @return [Boolean]
+    def title?
+      defined_value?(title)
+    end
+
     # @param value [String]
     # @param type [Symbol|NilClass]
     # @param iy [Fixnum]
     # @param ix [Fixnum]
     # @return [Vedeu::Char]
     def border(value, type = :border, iy = 0, ix = 0)
-      Vedeu::Char.new({ value:    value,
-                        parent:   interface,
-                        colour:   colour,
-                        style:    style,
-                        position: position(type, iy, ix),
-                        border:   type })
+      Vedeu::Char.new(value:    value,
+                      parent:   interface,
+                      colour:   colour,
+                      style:    style,
+                      position: position(type, iy, ix),
+                      border:   type)
+    end
+
+    # @return [Vedeu::Geometry]
+    def geometry
+      # @geometry ||= Vedeu.geometry.find(name)
+      interface.geometry
     end
 
     # @return [Vedeu::Interface]
@@ -335,11 +396,6 @@ module Vedeu
       }
     end
 
-    # @return [Vedeu::Interface]
-    def interface
-      @interface ||= Vedeu.interfaces.find(name)
-    end
-
     # @param name [Symbol]
     # @param iy [Fixnum]
     # @param ix [Fixnum]
@@ -347,24 +403,21 @@ module Vedeu
     def position(name, iy = 0, ix = 0)
       case name
       when :top_horizontal
-        Vedeu::Position[interface.y, (bx + ix)]
+        Vedeu::Position[geometry.y, (bx + ix)]
 
       when :bottom_horizontal
-        Vedeu::Position[interface.yn, (bx + ix)]
+        Vedeu::Position[geometry.yn, (bx + ix)]
 
       when :left_vertical
-        Vedeu::Position[(by + iy), interface.x]
+        Vedeu::Position[(by + iy), geometry.x]
 
       when :right_vertical
-        Vedeu::Position[(by + iy), interface.xn]
-
-      when :bottom_left  then interface.bottom_left
-      when :bottom_right then interface.bottom_right
-      when :top_left     then interface.top_left
-      when :top_right    then interface.top_right
-      else
-        nil
+        Vedeu::Position[(by + iy), geometry.xn]
 
+      when :bottom_left  then geometry.bottom_left
+      when :bottom_right then geometry.bottom_right
+      when :top_left     then geometry.top_left
+      when :top_right    then geometry.top_right
       end
     end
 

data/lib/vedeu/output/clear.rb

@@ -10,8 +10,14 @@ module Vedeu
       #
       # @return [Array|String]
       # @see #initialize
-      def clear(interface)
-        new(interface).write
+      def clear(interface, options = {})
+        if interface.visible?
+          new(interface, options).write
+
+        else
+          []
+
+        end
       end
       alias_method :render, :clear
 
@@ -20,9 +26,14 @@ module Vedeu
     # Return a new instance of Vedeu::Clear.
     #
     # @param interface [Interface]
+    # @param options [Hash]
+    # @option options clear_border [Boolean] see {#clear_border?}
+    # @option options use_terminal_colours [Boolean] see
+    #   {#use_terminal_colours?}
     # @return [Vedeu::Clear]
-    def initialize(interface)
+    def initialize(interface, options = {})
       @interface = interface
+      @options   = options
     end
 
     # For each visible line of the interface, set the foreground and background
@@ -31,31 +42,36 @@ module Vedeu
     #
     # @return [Array<Array<Vedeu::Char>>]
     def clear
-      @clear ||= Array.new(interface.border.height) do |iy|
-        Array.new(interface.border.width) do |ix|
-          Vedeu::Char.new({ value:    ' ',
-                            colour:   interface.colour,
+      if interface.visible?
+        Vedeu.log(type: :output, message: "Clearing: '#{interface.name}'")
+
+        @clear ||= Array.new(height) do |iy|
+          Array.new(width) do |ix|
+            Vedeu::Char.new(value:    ' ',
+                            colour:   colour,
                             style:    interface.style,
-                            position: position(iy, ix) })
+                            position: position(iy, ix))
+          end
         end
+      else
+        []
+
       end
     end
+    alias_method :render, :clear
+    alias_method :rendered, :clear
 
     # Clear the view and send to the terminal.
     #
     # @return [Array]
     def write
-      Vedeu.log(type: :output, message: "Clearing: '#{interface.name}'")
-
       if Vedeu::Configuration.drb?
-        Vedeu.trigger(:_drb_store_output_, clear)
+        Vedeu.trigger(:_drb_store_output_, rendered)
 
         Vedeu::HTMLRenderer.to_file(Vedeu::VirtualBuffer.retrieve)
       end
 
-      # Vedeu::FileRenderer.render(clear)
-
-      Vedeu::TerminalRenderer.render(clear)
+      Vedeu.renderers.render(rendered)
     end
 
     private
@@ -64,11 +80,80 @@ module Vedeu
     # @return [Interface]
     attr_reader :interface
 
+    # @return [Boolean] Indicates whether the area occupied by the border of the
+    #   interface should be cleared also.
+    def clear_border?
+      options[:clear_border]
+    end
+
+    # @return [Vedeu::Colour] The default background and foreground colours for
+    #   the terminal, or the colours of the interface.
+    def colour
+      if use_terminal_colours?
+        Colour.new(background: :default, foreground: :default)
+
+      else
+        interface.colour
+
+      end
+    end
+
+    # @return [Hash<Symbol => Boolean>]
+    def defaults
+      {
+        clear_border:         true,
+        use_terminal_colours: true,
+      }
+    end
+
+    # Returns the height of the area to be cleared.
+    #
+    # @return [Fixnum]
+    def height
+      if clear_border?
+        interface.height
+
+      else
+        interface.border.height
+
+      end
+    end
+
+    # @return [Hash<Symbol => Boolean>]
+    def options
+      @_options ||= defaults.merge!(@options)
+    end
+
     # @param iy [Fixnum]
     # @param ix [Fixnum]
     # @return [Vedeu::IndexPosition]
     def position(iy, ix)
-      Vedeu::IndexPosition[iy, ix, interface.border.by, interface.border.bx]
+      if clear_border?
+        Vedeu::IndexPosition[iy, ix, interface.y, interface.x]
+
+      else
+        Vedeu::IndexPosition[iy, ix, interface.border.by, interface.border.bx]
+
+      end
+    end
+
+    # @return [Boolean] Indicates whether the default terminal colours should be
+    #   used to clear the area.
+    def use_terminal_colours?
+      options[:use_terminal_colours]
+    end
+
+    # Returns the width of the area to be cleared.
+    #
+    # @return [Fixnum]
+    def width
+      if clear_border?
+        interface.width
+
+      else
+        interface.border.width
+
+      end
     end
 
   end # Clear

data/lib/vedeu/output/colour.rb

@@ -1,15 +1,24 @@
-require 'vedeu/support/coercions'
-
 module Vedeu
 
   # Provides a container for terminal escape sequences controlling the
   # foreground and background colours of a character or collection of
   # characters.
   #
+  # Vedeu uses HTML/CSS style notation (i.e. '#aadd00'), they can be used at the
+  # stream level, the line level or for the whole interface. Terminals generally
+  # support either 8, 16 or 256 colours, with few supporting full 24-bit colour.
+  #
+  # Vedeu attempts to detect the colour depth using the `$TERM` environment
+  # variable.
+  #
+  # To set your `$TERM` variable to allow 256 colour support:
+  #
+  # ```bash
+  # echo "export TERM=xterm-256color" >> ~/.bashrc
+  # ```
+  #
   class Colour
 
-    include Vedeu::Coercions
-
     # @!attribute [r] attributes
     # @return [Hash]
     attr_reader :attributes
@@ -22,6 +31,33 @@ module Vedeu
     # @return [Foreground|String]
     attr_reader :foreground
 
+    # @param value []
+    # @return [Object]
+    def self.coerce(value)
+      if value.nil?
+        new
+
+      elsif value.is_a?(self)
+        value
+
+      elsif value.is_a?(Hash)
+        if value.key?(:colour) && value[:colour].is_a?(self)
+          value
+
+        elsif value.key?(:background) || value.key?(:foreground)
+          new(value)
+
+        else
+          new
+
+        end
+
+      else
+        new(value)
+
+      end
+    end
+
     # Returns a new instance of Vedeu::Colour.
     #
     # @param attributes [Hash]
@@ -35,20 +71,28 @@ module Vedeu
       @foreground = Vedeu::Foreground.coerce(@attributes[:foreground])
     end
 
-    # Converts the value into a Vedeu::Foreground.
+    # Converts the value into a Vedeu::Background.
     #
     # @param value [String]
     # @return [String]
-    def foreground=(value)
-      @foreground = Vedeu::Foreground.coerce(value)
+    def background=(value)
+      @background = Vedeu::Background.coerce(value)
     end
 
-    # Converts the value into a Vedeu::Background.
+    # @param other [Vedeu::Char]
+    # @return [Boolean]
+    def eql?(other)
+      self.class == other.class && background == other.background &&
+        foreground == other.foreground
+    end
+    alias_method :==, :eql?
+
+    # Converts the value into a Vedeu::Foreground.
     #
     # @param value [String]
     # @return [String]
-    def background=(value)
-      @background = Vedeu::Background.coerce(value)
+    def foreground=(value)
+      @foreground = Vedeu::Foreground.coerce(value)
     end
 
     # Returns both or either of the converted attributes into a single escape
@@ -63,11 +107,11 @@ module Vedeu
 
     # The default values for a new instance of this class.
     #
-    # @return [Hash<Symbol => String>]
+    # @return [Hash<Symbol => NilClass>]
     def defaults
       {
+        background: '',
         foreground: '',
-        background: ''
       }
     end
 

data/lib/vedeu/output/compressor.rb

@@ -0,0 +1,59 @@
+module Vedeu
+
+  # During the conversion of a Vedeu::Char object into a string of escape
+  # sequences, this class removes multiple occurences of the same escape
+  # sequence, resulting in a smaller payload being sent to the renderer.
+  #
+  class Compressor
+
+    # @param output [Array<Array<Vedeu::Char>>]
+    # @return [Vedeu::Compressor]
+    def initialize(output)
+      @output = output
+      @colour = ''
+      @style  = ''
+    end
+
+    # @return [String]
+    def render
+      Array(output).flatten.map do |char|
+        if char.is_a?(Vedeu::Char)
+          out = ''
+          out << char.position.to_s
+          out << colour_for(char)
+          out << style_for(char)
+          out << char.value
+          out
+
+        else
+          char.to_s
+
+        end
+      end.join
+    end
+
+    private
+
+    attr_reader :output
+
+    # @param char [Vedeu::Char]
+    # @return [String]
+    def colour_for(char)
+      return '' if char.colour == @colour
+
+      @colour = char.colour
+      @colour.to_s
+    end
+
+    # @param char [Vedeu::Char]
+    # @return [String]
+    def style_for(char)
+      return '' if char.style == @style
+
+      @style = char.style
+      @style.to_s
+    end
+
+  end # Compressor
+
+end # Vedeu

data/lib/vedeu/output/html_char.rb

@@ -102,14 +102,16 @@ module Vedeu
 
     # @return [String|NilClass]
     def parent_bg
-      if char.parent_background && defined_value?(char.parent_background.to_html)
+      if char.parent_background &&
+         defined_value?(char.parent_background.to_html)
         char.parent_background.to_html
       end
     end
 
     # @return [String|NilClass]
     def parent_fg
-      if char.parent_foreground && defined_value?(char.parent_foreground.to_html)
+      if char.parent_foreground &&
+         defined_value?(char.parent_foreground.to_html)
         char.parent_foreground.to_html
       end
     end

data/lib/vedeu/output/null_border.rb

@@ -15,22 +15,27 @@ module Vedeu
 
     # @return [Fixnum]
     def bx
-      interface.x
+      geometry.x
     end
 
     # @return [Fixnum]
     def bxn
-      interface.xn
+      geometry.xn
     end
 
     # @return [Fixnum]
     def by
-      interface.y
+      geometry.y
     end
 
     # @return [Fixnum]
     def byn
-      interface.yn
+      geometry.yn
+    end
+
+    # @return [FalseClass]
+    def enabled?
+      false
     end
 
     # @return [Fixnum]
@@ -54,6 +59,13 @@ module Vedeu
     # @return [Vedeu::Interface]
     attr_reader :interface
 
+    # Returns the geometry for the interface.
+    #
+    # @return [Vedeu::Geometry]
+    def geometry
+      interface.geometry
+    end
+
   end # NullBorder
 
 end # Vedeu

data/lib/vedeu/output/output.rb

@@ -1,54 +1,46 @@
 require 'vedeu/output/renderers/all'
 require 'vedeu/output/virtual_buffer'
-require 'vedeu/support/terminal'
 
 module Vedeu
 
-  # Sends the interface to the terminal or output device.
+  # Sends the content to the renderers.
   #
   class Output
 
-    # Writes content (the provided interface object with associated lines,
-    # streams, colours and styles) to the area defined by the interface.
+    # Writes content to the defined renderers.
     #
     # @return [Array|String]
     # @see #initialize
-    def self.render(interface)
-      new(interface).render
+    def self.render(content)
+      new(content).render
     end
 
     # Return a new instance of Vedeu::Output.
     #
-    # @param interface [Interface]
+    # @param content [Array<Array<Vedeu::Char>>]
     # @return [Output]
-    def initialize(interface)
-      @interface = interface
+    def initialize(content)
+      @content = content
     end
 
-    # Send the view to the terminal.
+    # Send the view to the renderers.
     #
     # @return [Array]
     def render
       if Vedeu::Configuration.drb?
-        Vedeu.trigger(:_drb_store_output_, rendered)
+        Vedeu.trigger(:_drb_store_output_, content)
 
         Vedeu::HTMLRenderer.to_file(Vedeu::VirtualBuffer.retrieve)
       end
 
-      # Vedeu::FileRenderer.render(rendered)
-
-      Vedeu::TerminalRenderer.render(rendered)
+      Vedeu.renderers.render(content)
     end
 
     private
 
-    # @!attribute [r] interface
-    # @return [Interface]
-    attr_reader :interface
-
-    def rendered
-      @rendered ||= interface.render
-    end
+    # @!attribute [r] content
+    # @return [Array<Array<Vedeu::Char>>]
+    attr_reader :content
 
   end # Output