vedeu 0.5.13 → 0.6.0

data/lib/vedeu/buffers/buffer.rb

@@ -78,6 +78,13 @@ module Vedeu
       true
     end
 
+    # Clear the buffer.
+    #
+    # @return [Array<Array<Vedeu::Views::Char>>]
+    def clear
+      Vedeu::Output.render(Vedeu::Clear::NamedInterface.render(name))
+    end
+
     # Return a boolean indicating content presence on the buffer type.
     #
     # @return [Boolean] Whether the buffer targetted has content.
@@ -110,7 +117,7 @@ module Vedeu
     #
     # @return [Array<Array<Array<Vedeu::Views::Char>>>]
     def hide
-      Vedeu::Output.render(clear_buffer)
+      Vedeu::Output.render(clear)
     end
 
     # Return the content for this buffer.
@@ -166,13 +173,6 @@ module Vedeu
       end
     end
 
-    # Clear the buffer.
-    #
-    # @return [Array<Array<Vedeu::Views::Char>>]
-    def clear_buffer
-      @clear_buffer ||= Vedeu::Clear::NamedInterface.render(name)
-    end
-
     # Returns the default options/attributes for this class.
     #
     # @return [Hash<Symbol => NilClass, String>]

data/lib/vedeu/configuration/api.rb

@@ -183,6 +183,20 @@ module Vedeu
       end
       alias_method :cooked, :cooked!
 
+      # Sets the terminal mode to `fake`. Default terminal mode is `raw`.
+      #
+      # @example
+      #   Vedeu.configure do
+      #     fake!
+      #     # ...
+      #   end
+      #
+      # @return [Boolean]
+      def fake!
+        options[:terminal_mode] = :fake
+      end
+      alias_method :fake, :fake!
+
       # Sets the terminal mode to `raw`. Default terminal mode is `raw`.
       # Also, see {Vedeu::Config::API#cooked!}
       #
@@ -390,30 +404,37 @@ module Vedeu
       end
       alias_method :compression!, :compression
 
-      # Sets the terminal mode. Valid values can be either ':raw' or ':cooked'.
+      # Sets the terminal mode. Valid values can be either ':cooked', ':fake' or
+      # :raw'.
       #
       #   Vedeu.configure do
+      #     terminal_mode :cooked
+      #
+      #     # or...
+      #
+      #     terminal_mode :fake
+      #
+      #     # or...
+      #
       #     terminal_mode :raw
-      #     # ...
-      #   end
       #
-      #   Vedeu.configure do
-      #     terminal_mode :cooked
-      #     # ...
+      #     # ... some code
       #   end
       #
-      # @param mode [Symbol] Either ':raw' or ':cooked'.
-      # @raise [Vedeu::InvalidSyntax] When the mode is not ':raw' or ':cooked'.
+      # @param mode [Symbol] Either ':cooked', ':fake' or ':raw'.
+      # @raise [Vedeu::InvalidSyntax] When the mode is not ':cooked', ':fake' or
+      #   ':raw'.
       # @return [Symbol]
-      # @see Vedeu::Config::API#raw!
       # @see Vedeu::Config::API#cooked!
+      # @see Vedeu::Config::API#fake!
+      # @see Vedeu::Config::API#raw!
       def terminal_mode(mode)
-        if mode == :raw || mode == :cooked
+        if [:cooked, :fake, :raw].include?(mode)
           options[:terminal_mode] = mode
 
         else
           fail Vedeu::InvalidSyntax,
-               'Terminal mode can be set to either :raw or :cooked'
+               'Terminal mode can be set to either :cooked, :fake or :raw'
 
         end
       end

data/lib/vedeu/configuration/cli.rb

@@ -72,6 +72,7 @@ module Vedeu
           :drb_host,
           :drb_port,
           :drb_width,
+          :fake,
           :interactive,
           :log,
           :raw,
@@ -194,6 +195,13 @@ module Vedeu
       #
       #    -i, --interactive
       #
+      # @return [OptionParser]
+      def fake
+        parser.on('-f', '--fake', 'Run application in fake mode.') do
+          options[:terminal_mode] = :fake
+        end
+      end
+
       # @return [OptionParser]
       def interactive
         parser.on('-i', '--interactive',

data/lib/vedeu/cursor/move.rb

@@ -182,6 +182,7 @@ module Vedeu
       @coordinate ||= Vedeu::Coordinate.new(name, oy, ox)
     end
 
+    # @return [Vedeu::Cursor]
     # @see Vedeu::Cursors#by_name
     def cursor
       @cursor ||= Vedeu.cursors.by_name(name)

data/lib/vedeu/distributed/templates/default_configuration.vedeu

@@ -10,6 +10,7 @@ Vedeu.configure do
 
   # terminal_mode :raw
   # cooked!
+  # fake!
   # raw!
 
   # run_once!

data/lib/vedeu/exceptions.rb

@@ -35,7 +35,7 @@ module Vedeu
   end # MissingRequired
 
   # Raised intentionally when the client application wishes to switch between
-  # cooked and raw (or vice versa) terminal modes.
+  # cooked, fake and raw terminal modes.
   #
   # @see Vedeu::Application
   #

data/lib/vedeu/geometry/position.rb

@@ -104,6 +104,34 @@ module Vedeu
     end
     alias_method :to_str, :to_s
 
+    # Increase y coordinate; moves down.
+    #
+    # @return [Vedeu::Position]
+    def down
+      Vedeu::Position.new(y + 1, x)
+    end
+
+    # Decrease x coordinate; moves left.
+    #
+    # @return [Vedeu::Position]
+    def left
+      Vedeu::Position.new(y, x - 1)
+    end
+
+    # Increase x coordinate; moves right.
+    #
+    # @return [Vedeu::Position]
+    def right
+      Vedeu::Position.new(y, x + 1)
+    end
+
+    # Decrease y coordinate; moves up.
+    #
+    # @return [Vedeu::Position]
+    def up
+      Vedeu::Position.new(y - 1, x)
+    end
+
     private
 
     # Returns the escape sequence to reposition the cursors at the coordinates

data/lib/vedeu/input/capture.rb

@@ -0,0 +1,76 @@
+module Vedeu
+
+  module Editor
+
+    # Capture input from the terminal via 'getch'.
+    #
+    class Capture
+
+      ESCAPE_KEY_CODE = 27 # \e
+
+      # @param console [IO]
+      # @return [String|Symbol]
+      def self.read(console)
+        new(console).read
+      end
+
+      # Returns a new instance of Vedeu::Editor::Capture.
+      #
+      # @param console [IO]
+      # @return [Vedeu::Editor::Capture]
+      def initialize(console)
+        @console = console
+      end
+
+      # @return [String|Symbol]
+      def read
+        Vedeu::InputTranslator.translate(keys)
+      end
+
+      private
+
+      # @return [String]
+      def keys
+        keys = console.getch
+
+        if keys.ord == ESCAPE_KEY_CODE
+          # Vedeu.log(type: :debug, message: "#keys: Escape detected...")
+          @chars = 3
+
+          begin
+            # Vedeu.log(type:    :debug,
+            #           message: "#keys: Attempting read_nonblock(#{@chars})")
+            keys << console.read_nonblock(@chars)
+
+          rescue IO::WaitReadable
+            # Vedeu.log(type:    :debug,
+            #           message: "#keys: (#{@chars}) Rescuing IO::WaitReadable")
+            IO.select([console])
+            @chars -= 1
+            retry
+
+          rescue IO::WaitWritable
+            # Vedeu.log(type:    :debug,
+            #           message: "#keys: (#{@chars}) Rescuing IO::WaitWritable")
+            IO.select(nil, [console])
+            @chars -= 1
+            retry
+
+          end
+        end
+        # Vedeu.log(type:    :debug,
+        #           message: "#keys: Sending result: #{keys.inspect}")
+
+        keys
+      end
+
+      # @return [IO]
+      def console
+        @console || Vedeu::Terminal.console
+      end
+
+    end # Capture
+
+  end # Editor
+
+end # Vedeu

data/lib/vedeu/input/editor/all.rb

@@ -0,0 +1,19 @@
+module Vedeu
+
+  # Provide a mechanism to edit individual lines of the view.
+  #
+  module Editor
+
+  end # Editor
+
+end # Vedeu
+
+require 'vedeu/input/capture'
+require 'vedeu/input/editor/editor'
+
+require 'vedeu/input/editor/cropper'
+require 'vedeu/input/editor/line'
+require 'vedeu/input/editor/lines'
+require 'vedeu/input/editor/virtual_cursor'
+require 'vedeu/input/editor/document'
+require 'vedeu/input/editor/documents'

data/lib/vedeu/input/editor/cropper.rb

@@ -0,0 +1,74 @@
+module Vedeu
+
+  module Editor
+
+    # Crop the lines to the visible area of the document, as defined by the
+    # geometry provided.
+    #
+    class Cropper
+
+      # Returns a new instance of Vedeu::Editor::Cropper.
+      #
+      # @param lines [Vedeu::Editor::Lines]
+      # @param height [Fixnum]
+      # @param width [Fixnum]
+      # @param ox [Fixnum]
+      # @param oy [Fixnum]
+      # @return [Vedeu::Editor::Cropper]
+      def initialize(lines:, height:, width:, ox:, oy:)
+        @lines  = lines
+        @height = height
+        @width  = width
+        @ox     = ox
+        @oy     = oy
+      end
+
+      # Returns the lines cropped.
+      #
+      # @note If there are no lines of content, we return an empty array. If
+      # there are any empty lines, then they are discarded.
+      #
+      # @return [Array<void>]
+      def cropped
+        lines.map { |line| columns(line) }
+      end
+
+      protected
+
+      # @!attribute [r] height
+      # @return [Fixnum]
+      attr_reader :height
+
+      # @!attribute [r] width
+      # @return [Fixnum]
+      attr_reader :width
+
+      # @!attribute [r] ox
+      # @return [Fixnum]
+      attr_reader :ox
+
+      # @!attribute [r] oy
+      # @return [Fixnum]
+      attr_reader :oy
+
+      private
+
+      # Return a range of visible lines.
+      #
+      # @return [Vedeu::Editor::Lines]
+      def lines
+        (@lines[oy...(oy + height)] || [])
+      end
+
+      # Return a range of visible characters from each line.
+      #
+      # @return [String]
+      def columns(line)
+        (line[ox...(ox + width)] || '')
+      end
+
+    end # Editor
+
+  end # Cropper
+
+end # Vedeu

data/lib/vedeu/input/editor/document.rb

@@ -0,0 +1,254 @@
+module Vedeu
+
+  module Editor
+
+    # A collection of keypresses ordered by input.
+    #
+    class Document
+
+      include Vedeu::Model
+      extend Forwardable
+
+      def_delegators :border,
+                     :bx,
+                     :bxn,
+                     :by,
+                     :byn,
+                     :height,
+                     :width
+
+      def_delegators :cursor,
+                     :bol,
+                     :down,
+                     :left,
+                     :ox,
+                     :oy,
+                     :right,
+                     :up,
+                     :x,
+                     :y
+
+      # @!attribute [r] attributes
+      # @return [Hash]
+      attr_reader :attributes
+
+      # @!attribute [rw] data
+      # @return [String]
+      attr_accessor :data
+
+      # @!attribute [rw] name
+      # @return [String]
+      attr_accessor :name
+
+      # Returns a new instance of Vedeu::Editor::Document.
+      #
+      # @param attributes [Hash]
+      # @option attributes data [String]
+      # @option attributes name [String]
+      # @option attributes repository [Vedeu::Repository]
+      # @return [Vedeu::Editor::Document]
+      def initialize(attributes = {})
+        @attributes = defaults.merge!(attributes)
+
+        @attributes.each do |key, value|
+          instance_variable_set("@#{key}", value || defaults.fetch(key))
+        end
+      end
+
+      # Clear the document content in the terminal.
+      #
+      # @return [void]
+      def clear
+        Vedeu::Direct.write(value: clear_output, x: bx, y: by)
+      end
+
+      # Deletes the character from the line where the cursor is currently
+      # positioned.
+      #
+      # @return [Vedeu::Editor::Document]
+      def delete_character
+        @lines = lines.delete_character(y, x - 1)
+
+        left
+
+        store
+      end
+
+      # Delete a line.
+      #
+      # @return [Vedeu::Editor::Document]
+      def delete_line
+        @lines = lines.delete_line(y)
+
+        up
+
+        store
+      end
+
+      # Inserts the given character in to the line where the cursor is currently
+      # positioned.
+      #
+      # @param character [String|Symbol]
+      # @return [Vedeu::Editor::Document]
+      def insert_character(character)
+        return self if character.is_a?(Symbol)
+
+        @lines = lines.insert_character(character, y, x)
+
+        right
+
+        store
+      end
+
+      # Insert an empty line.
+      #
+      # @return [Vedeu::Editor::Document]
+      def insert_line
+        down
+
+        @lines = lines.insert_line(Vedeu::Editor::Line.new, y)
+
+        bol
+
+        store
+      end
+
+      # Returns the current line from the collection of lines.
+      #
+      # @return [Array<String|void>]
+      def line
+        lines.line(y)
+      end
+
+      # Returns the collection of lines which constitutes the document content.
+      #
+      # @return [Array<String|void>]
+      def lines
+        @lines ||= if present?(data)
+                     Vedeu::Editor::Lines.coerce(data)
+
+                   else
+                     defaults[:data]
+
+                   end
+      end
+
+      # Render the document content in the terminal.
+      #
+      # @return [void]
+      def render
+        clear
+
+        Vedeu::Direct.write(value: output, x: bx, y: by)
+      end
+
+      # Reset the document to the empty state.
+      #
+      # @return [Vedeu::Editor::Document]
+      def reset!
+        @cursor = cursor.reset!
+
+        @lines = defaults[:data]
+
+        store
+      end
+
+      # Returns the document as a string with line breaks if there is more than
+      # one line.
+      #
+      # @return [String]
+      def retrieve
+        lines.map(&:to_s).join("\n")
+      end
+
+      # Store the document in the documents repository and render the view.
+      #
+      # @return [Vedeu::Editor::Document]
+      def store
+        super
+
+        render
+
+        self
+      end
+
+      private
+
+      # Retrieve the dimensions of the document from the interface of the same
+      # name.
+      #
+      # @return [Vedeu::Border]
+      def border
+        @border ||= Vedeu.borders.by_name(name)
+      end
+
+      # Return the data needed to clear the area which the document is using.
+      #
+      # @return [String]
+      def clear_output
+        clear_output = ''
+
+        (by..byn).each do |row|
+          clear_output << "\e[#{row};#{bx}H" + (' ' * width)
+        end
+
+        # reset cursor to top left of document
+        clear_output << "\e[#{by};#{bx}H"
+      end
+
+      # Returns the default options/attributes for this class.
+      #
+      # @return [Hash]
+      def defaults
+        {
+          data:       Vedeu::Editor::Lines.new([Vedeu::Editor::Line.new]),
+          name:       nil,
+          repository: Vedeu.documents,
+        }
+      end
+
+      # Return the data needed to render the document.
+      #
+      # @return [String]
+      def output
+        output = ''
+
+        visible.each_with_index do |line, y_index|
+          output << Vedeu::Position.new((by + y_index), bx).to_s + line.to_s
+        end
+
+        output << cursor.to_s
+
+        output
+      end
+
+      # Return a virtual cursor to track the cursor position within the
+      # document.
+      #
+      # @return [Vedeu::Editor::VirtualCursor]
+      def cursor
+        @cursor ||= Vedeu::Editor::VirtualCursor.new(y:   0,
+                                                     x:   0,
+                                                     by:  by,
+                                                     bx:  bx,
+                                                     byn: byn,
+                                                     bxn: bxn)
+      end
+
+      # Return only the visible lines for the document based on the current
+      # virtual cursor position.
+      #
+      # @return [Vedeu::Editor::Lines]
+      def visible
+        Vedeu::Editor::Cropper.new(lines:  lines,
+                                   height: height,
+                                   width:  width,
+                                   ox:     ox,
+                                   oy:     oy).cropped
+      end
+
+    end # Document
+
+  end # Editor
+
+end # Vedeu