vedeu 0.2.8 → 0.2.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2156b1bd78d30aece557893b5bf7b96a9253c1b9
-  data.tar.gz: aac032a4be3cfc9e34dfa6103daafd75502ada05
+  metadata.gz: fd5bd7cd569896aed34eadea8a2bb15312c99d4a
+  data.tar.gz: ea45bf2468c2ce0d22250da6f2b903ada4ed5028
 SHA512:
-  metadata.gz: 84e29f41f956f91c2c48d650a525029e925c22a076490ebf0829c92b42a2935501c8b28e4b8a3d5d6098ff6c2f5126c4d89995d0c11d0b3807e830c1dca1e7c5
-  data.tar.gz: d30411340d6a5ab8e8fbefb4e612b66bb29a61bc3b5ed74fc220b37ac9ee02accd1caf426df4732982f8657fcee799429bee8032289591565866571e0535e004
+  metadata.gz: 796459529347814e7644f0d9c4903c74dd197c93c548f50b06eb2c8fe5fc13c783f93bb8a09e02de6668da7b739310ee0f428521c2a5bf68eb5addc0f3cb32b9
+  data.tar.gz: 18c57141d04b4a2f2034ebdbe0384ba05d29a2f6e3ccf64166192c999b55ca6123264da5cfaabd26d3a22d8aee28e5d6f20309caa56131a13270b00bf00639d0

data/lib/vedeu.rb

@@ -52,6 +52,7 @@ require 'vedeu/support/position'
 require 'vedeu/support/esc'
 require 'vedeu/support/terminal'
 
+require 'vedeu/models/buffer'
 require 'vedeu/models/char'
 require 'vedeu/models/colour'
 require 'vedeu/models/cursor'

data/lib/vedeu/application.rb

@@ -43,7 +43,7 @@ module Vedeu
     # - We enter into the main sequence where the application will either run
     #   once or continuous, interactively or standalone.
     #
-    # @return []
+    # @return [Array] The last output sent to the terminal.
     def start
       Terminal.open do
         Terminal.set_cursor_mode

data/lib/vedeu/models/buffer.rb

@@ -0,0 +1,103 @@
+module Vedeu
+
+  # The Buffer object represents the states of display for an interface. The
+  # states are 'front', 'back' and 'previous'.
+  #
+  # - 'front':    The currently displayed buffer; contains the content which was
+  #               last output.
+  # - 'back':     The next buffer to be displayed; contains the content which
+  #               will be shown on next refresh.
+  # - 'previous': The previous buffer which was displayed; contains the content
+  #               that was shown before 'front'.
+  #
+  class Buffer
+
+    attr_reader :back, :front, :name, :previous
+    alias_method :current, :front
+
+    # Return a new instance of Buffer.
+    #
+    # @param attributes [Hash]
+    # @return [Buffer]
+    def initialize(attributes = {})
+      @attributes = defaults.merge(attributes)
+
+      @name     = @attributes[:name]
+      @back     = @attributes[:back]
+      @front    = @attributes[:front]
+      @previous = @attributes[:previous]
+    end
+
+    # Return a boolean indicating content on the front buffer.
+    #
+    # @return [Boolean]
+    def front?
+      front.any? { |k, v| k == :lines && v.any? }
+    end
+    alias_method :current?, :front?
+
+    # Return a boolean indicating content on the back buffer.
+    #
+    # @return [Boolean]
+    def back?
+      back.any? { |k, v| k == :lines && v.any? }
+    end
+
+    # Return a boolean indicating content on the previous buffer.
+    #
+    # @return [Boolean]
+    def previous?
+      previous.any? { |k, v| k == :lines && v.any? }
+    end
+
+    # Add the content to the back buffer, then update the repository. Returns
+    # boolean indicating that the repository was updated.
+    #
+    # @param content [Hash]
+    # @return [Boolean]
+    def add(content = {})
+      self.back = content
+
+      update!
+    end
+
+    # Return a boolean indicating content was swapped between buffers. It also
+    # resets the offsets (i.e. scroll/cursor position).
+    #
+    # @return [Boolean]
+    def swap
+      return false unless back?
+
+      # Offsets.update({ name: name })
+
+      self.previous = front
+      self.front    = back
+      self.back     = {}
+
+      update!
+    end
+
+    private
+
+    attr_writer :back, :front, :previous
+
+    # @see Buffers#update
+    def update!
+      Buffers.update(self)
+    end
+
+    # Return the default attributes of a Buffer.
+    #
+    # @return [Hash]
+    def defaults
+      {
+        name:     '',
+        back:     {},
+        front:    {},
+        previous: {},
+      }
+    end
+
+  end # Buffer
+
+end # Vedeu

data/lib/vedeu/output/clear.rb

@@ -4,31 +4,56 @@ module Vedeu
   # class is called every time an interface is rendered to prepare the area
   # for new data.
   #
+  # @note We don't simply clear the entire terminal as this would remove the
+  #   content of other interfaces which are being displayed.
+  #
+  # @todo What if an interface 'moves' or changes shape due to the terminal
+  #   resizing?
+  #
   # @api private
   class Clear
 
     # Blanks the area defined by the interface.
     #
     # @param interface [Interface]
+    # @param options [Hash]
     # @return [String]
-    def self.call(interface)
-      new(interface).clear
+    # @see #initialize
+    def self.call(interface, options = {})
+      new(interface, options).clear
     end
 
     # Returns a new instance of Clear.
     #
     # @param interface [Interface]
+    # @param options [Hash]
+    # @option options :direct [Boolean] Send escape sequences to clear an area
+    #   directly to the Terminal.
     # @return [Clear]
-    def initialize(interface)
+    def initialize(interface, options = {})
       @interface = interface
+      @options   = defaults.merge!(options)
     end
 
+    # Send the cleared area to the terminal.
+    #
+    # @return [Array]
+    def clear
+      return Terminal.output(view) if direct?
+
+      view
+    end
+
+    private
+
+    attr_reader :interface, :options
+
     # For each visible line of the interface, set the foreground and background
     # colours to those specified when the interface was defined, then starting
     # write space characters over the area which the interface occupies.
     #
     # @return [String]
-    def clear
+    def view
       Vedeu.log("Clearing view: '#{interface.name}'")
 
       rows.inject([colours]) do |line, index|
@@ -36,10 +61,6 @@ module Vedeu
       end.join
     end
 
-    private
-
-    attr_reader :interface
-
     # @return [String]
     def colours
       interface.colour.to_s
@@ -50,6 +71,18 @@ module Vedeu
       interface.height.times
     end
 
+    # @return [Boolean]
+    def direct?
+      options[:direct]
+    end
+
+    # @return [Hash]
+    def defaults
+      {
+        direct: true
+      }
+    end
+
   end # Clear
 
 end # Vedeu

data/lib/vedeu/output/compositor.rb

@@ -38,49 +38,74 @@ module Vedeu
 
     # Renders the cursor into the currently focussed interface. May be hidden.
     #
-    # @return [String]
+    # @return [String] The escape sequence to render the cursor as shown or
+    #   hidden.
     def cursor
-      Interface.new(Vedeu::Interfaces.find(Focus.current)).cursor.to_s
+      Interface.new(Interfaces.find(Focus.current)).cursor.to_s
     end
 
-    # Renders the buffer unless empty, otherwise clears the area which the
-    # interface occupies.
+    # Return the content for this buffer.
     #
-    # @return [String]
+    # - If we have new content (i.e. content on 'back') to be shown, we first
+    #   clear the area occupied by the previous content, then clear the area for
+    #   the new content, and then finally render the new content.
+    # - If there is no new content (i.e. 'back' is empty), check the 'front'
+    #   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.
+    #
+    # @return [Hash]
     def view
-      if buffer
-        Render.call(Interface.new(new_interface))
+      if buffer.back?
+        Clear.call(compose(buffer.previous)) if buffer.previous?
+
+        buffer.swap
+
+        Render.call(compose(buffer.front))
+
+      elsif buffer.front?
+        Render.call(compose(buffer.front))
+
+      elsif buffer.previous?
+        Render.call(compose(buffer.previous))
 
       else
-        Clear.call(Interface.new(interface))
+        Clear.call(compose({}), { direct: false })
 
       end
     end
 
-    # Combine the buffer attributes with the interface attributes. Buffer
-    # presentation attributes will override interface defaults.
+    # Return a new instance of Interface built by combining the buffer content
+    # attributes with the stored interface attributes.
     #
-    # @return [Hash]
-    def new_interface
-      combined = interface
-      combined[:lines]  = buffer[:lines]
-      combined[:colour] = buffer[:colour] if defined_value?(buffer[:colour])
-      combined[:style]  = buffer[:style]  if defined_value?(buffer[:style])
-      combined
+    # @return [Interface]
+    def compose(content)
+      if defined_value?(content[:geometry])
+        content[:geometry].each do |k, v|
+          interface[:geometry][k] = v if defined_value?(k)
+        end
+      end
+
+      interface[:lines]  = content[:lines]
+      interface[:colour] = content[:colour] if defined_value?(content[:colour])
+      interface[:style]  = content[:style]  if defined_value?(content[:style])
+
+      Interface.new(interface)
     end
 
     # Returns the attributes of the named interface (layout).
     #
     # @return [Hash]
     def interface
-      @_interface ||= Vedeu::Interfaces.find(name)
+      @_interface ||= Interfaces.find(name)
     end
 
-    # Returns the attributes of the latest buffer (view).
+    # Return the named Buffer (view).
     #
-    # @return [Hash|NilClass]
+    # @return [Buffer]
     def buffer
-      @_buffer ||= Vedeu::Buffers.latest(name)
+      @_buffer ||= Buffers.find(name)
     end
 
   end # Compositor

data/lib/vedeu/output/render.rb

@@ -30,7 +30,7 @@ module Vedeu
     #
     # @return [String]
     def render
-      out = [clear]
+      out = [ Clear.call(interface, { direct: false }) ]
 
       Vedeu.log("Rendering view: '#{interface.name}'")
 
@@ -45,10 +45,6 @@ module Vedeu
 
     attr_reader :interface
 
-    def clear
-      Clear.call(interface)
-    end
-
   end # Render
 
 end # Vedeu

data/lib/vedeu/repositories/buffers.rb

@@ -14,107 +14,50 @@ module Vedeu
     # buffer added to storage.
     #
     # @param attributes [Hash]
-    # @return [String]
+    # @return [String] The name of the buffer that has been added.
     def add(attributes)
       validate_attributes!(attributes)
 
-      if registered?(attributes[:name])
-        buffer = find(attributes[:name])
+      name = attributes[:name]
 
-        buffer[:back_buffer] = attributes
+      if registered?(name)
+        Vedeu.log("Adding new content to existing buffer: '#{name}'")
 
-      else
-        storage.store(attributes[:name], {
-          back_buffer:  attributes,
-          front_buffer: nil,
-        })
+        find(name).add(attributes)
 
-      end
+      else
+        Vedeu.log("Adding new buffer: '#{name}'")
 
-      attributes[:name]
-    end
+        Buffer.new({ name: name }).add(attributes)
 
-    # Return the named back buffer.
-    #
-    # @param name [String]
-    # @raise [BufferNotFound] When the named buffer cannot be found.
-    # @return [Hash|Nil]
-    def back(name)
-      find(name)[:back_buffer]
-    end
+      end
 
-    # Return the named front buffer.
-    #
-    # @param name [String]
-    # @raise [BufferNotFound] When the named buffer cannot be found.
-    # @return [Hash|Nil]
-    def front(name)
-      find(name)[:front_buffer]
+      name
     end
 
-    # Returns the latest content for the named buffer. The latest content always
-    # goes on to the back buffer. The content which was last output is on the
-    # front buffer.
-    #
-    # When the back buffer has new content, we swap the back onto the front and
-    # return the front buffer to be rendered.
+    # Update the repository with the provided Buffer. Returns a boolean
+    # indicating whether this was successful.
     #
-    # When the back buffer has no new content, we display that which we
-    # previously displayed, by returning the front buffer.
-    #
-    # If both the back and front buffers have no content, then the view is blank
-    # and we should return nothing.
-    #
-    # @param name [String]
-    # @return [Hash|NilClass]
-    def latest(name)
-      swap_buffers(name) if new_content?(name)
+    # @param buffer [Buffer]
+    # @return [Boolean]
+    def update(buffer)
+      storage.store(buffer.name, buffer)
 
-      front(name)
+      true
     end
 
     private
 
-    # Swap the named back buffer into the front buffer of the same name. This is
-    # called when the back buffer has new content (perhaps as part of a
-    # refresh). It also resets the offsets (i.e. scroll position)
-    #
-    # @param name [String]
-    # @return [Hash]
-    def swap_buffers(name)
-      buffer = find(name)
-
-      Offsets.update({ name: name })
-
-      storage.store(name, {
-        front_buffer: buffer[:back_buffer],
-        back_buffer:  nil,
-      })
-    end
-
-    # Return a boolean indicating whether the named back buffer has new content.
-    #
-    # @param name [String]
-    # @return [Boolean]
-    def new_content?(name)
-      defined_value?(back(name))
-    end
-
     # @return [Hash]
     def in_memory
-      Hash.new do |hash, interface_name|
-        hash[interface_name] = {
-          front_buffer: nil,
-          back_buffer:  nil,
-        }
-      end
+      {}
     end
 
     # @param name [String]
     # @raise [BufferNotFound] When the entity cannot be found with this name.
     # @return [BufferNotFound]
     def not_found(name)
-      fail BufferNotFound, "Cannot find buffer with this name: #{name}."
+      fail BufferNotFound, "Cannot find buffer: '#{name}'"
     end
 
   end # Buffers