vedeu 0.5.13 → 0.6.0

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

@@ -0,0 +1,18 @@
+module Vedeu
+
+  module Editor
+
+    # Allows the storing of documents.
+    #
+    class Documents < Vedeu::Repository
+
+      singleton_class.send(:alias_method, :documents, :repository)
+
+      real Vedeu::Editor::Document
+      null Vedeu::Editor::Document
+
+    end # Documents
+
+  end # Editor
+
+end # Vedeu

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

@@ -0,0 +1,100 @@
+module Vedeu
+
+  module Editor
+
+    # Handles keypresses for a named document whilst the terminal is in fake
+    # mode.
+    #
+    class Editor
+
+      include Vedeu::Common
+      extend Forwardable
+
+      def_delegators :document,
+                     :clear,
+                     :delete_character,
+                     :down,
+                     :insert_character,
+                     :insert_line,
+                     :left,
+                     :render,
+                     :reset!,
+                     :retrieve,
+                     :right,
+                     :up
+
+      # @param name [String]
+      # @param input [String|Symbol]
+      # @return [void]
+      def self.keypress(input:, name:)
+        new(input: input, name: name).keypress
+      end
+
+      # Returns a new instance of Vedeu::Editor::Editor.
+      #
+      # @param name [String]
+      # @param input [String|Symbol]
+      # @return [Vedeu::Editor::Editor]
+      def initialize(input:, name:)
+        @input = input
+        @name  = name
+      end
+
+      # @return [String|Symbol]
+      def keypress
+        return input unless document
+
+        case input
+        when :backspace then delete_character
+        when :ctrl_c    then Vedeu.trigger(:_exit_)
+        when :down      then down
+        when :enter     then insert_line
+        when :escape    then Vedeu.trigger(:_mode_switch_)
+        when :left      then left
+        when :right     then right
+        when :tab       then command
+        when :up        then up
+        # when ''         then delete_line
+        else
+          insert_character(input)
+        end
+
+        render unless input == :enter
+      end
+
+      protected
+
+      # @!attribute [r] input
+      # @return [Symbol|String]
+      attr_reader :input
+
+      # @!attribute [r] name
+      # @return [String]
+      attr_reader :name
+
+      private
+
+      #
+      # @return []
+      def command
+        command = retrieve
+
+        reset!
+
+        clear
+
+        Vedeu.trigger(:_command_, command)
+      end
+
+      # Return the document by name from the documents repository.
+      #
+      # @return [Vedeu::Editor::Document]
+      def document
+        @document ||= Vedeu.documents.by_name(name)
+      end
+
+    end # Editor
+
+  end # Editor
+
+end # Vedeu

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

@@ -0,0 +1,143 @@
+module Vedeu
+
+  module Editor
+
+    # Manipulate a single line of an Vedeu::Editor::Document.
+    #
+    class Line
+
+      # @!attribute [rw] line
+      # @return [String]
+      attr_accessor :line
+      alias_method :to_s, :line
+
+      # Coerce a line into a new instance of Vedeu::Editor::Line.
+      #
+      # @param line [String|Vedeu::Editor::Line]
+      # @return [Vedeu::Editor::Line]
+      def self.coerce(line)
+        return line if line.is_a?(self)
+
+        if line.is_a?(String)
+          new(line)
+
+        else
+          new
+
+        end
+      end
+
+      # Returns a new instance of Vedeu::Editor::Line.
+      #
+      # @param line [String|NilClass]
+      # @return [Vedeu::Editor::Line]
+      def initialize(line = nil)
+        @line = line || ''
+      end
+
+      # Return a character or collection of characters (if index is a Range).
+      #
+      # @param index [Fixnum|Range]
+      # @return [String]
+      def [](index)
+        line[index]
+      end
+
+      # Return the character from the line positioned at the given index.
+      #
+      # @param index [Fixnum|NilClass]
+      # @return [String|NilClass]
+      def character(index = nil)
+        return ''       if line && line.empty?
+        return line[-1] unless index
+
+        if index <= 0
+          line[0]
+
+        elsif index && index <= size
+          line[index]
+
+        else
+          line[-1]
+
+        end
+      end
+
+      # Delete the character from the line positioned at the given index.
+      #
+      # @param index [Fixnum|NilClass]
+      # @return [String]
+      def delete_character(index = nil)
+        return self if line.empty? || (index && index <= 0)
+
+        new_line = if index && index <= size
+                     line.dup.tap { |line| line.slice!(index) }
+
+                   else
+                     line.chop
+
+                   end
+
+        Vedeu::Editor::Line.coerce(new_line)
+      end
+
+      # Returns a boolean indicating whether there are characters on this line.
+      #
+      # @return [Boolean]
+      def empty?
+        size == 0
+      end
+
+      # An object is equal when its values are the same.
+      #
+      # @param other [Vedeu::Editor::Line]
+      # @return [Boolean]
+      def eql?(other)
+        self.class == other.class && line == other.line
+      end
+      alias_method :==, :eql?
+
+      # Insert the character on the line positioned at the given index.
+      #
+      # @param character [String]
+      # @param index [Fixnum|NilClass]
+      # @return [String]
+      def insert_character(character, index = nil)
+        new_line = if index
+                     if index <= 0
+                       line.insert(0, character)
+
+                     elsif index >= size
+                       line << character
+
+                     else
+                       line.insert(index, character)
+
+                     end
+                   else
+                     line + character
+
+                   end
+
+        Vedeu::Editor::Line.coerce(new_line)
+      end
+
+      # Return the size of the line in characters.
+      #
+      # @return [Fixnum]
+      def size
+        line.size
+      end
+
+      # Return the line as a collection of Vedeu::Views::Char objects.
+      #
+      # @return [Array<Vedeu::Views::Char>]
+      def to_chars
+        line.chars.map { |char| Vedeu::Views::Char.new(value: char) }
+      end
+
+    end # Line
+
+  end # Editor
+
+end # Vedeu

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

@@ -0,0 +1,199 @@
+module Vedeu
+
+  module Editor
+
+    # Manipulate the lines of an Vedeu::Editor::Document.
+    #
+    class Lines
+
+      include Enumerable
+
+      # @!attribute [rw] lines
+      # @return [String]
+      attr_accessor :lines
+
+      # Coerce a document into a new instance of Vedeu::Editor::Lines.
+      #
+      # @param document [Array<String>|Vedeu::Editor::Lines]
+      # @return [Vedeu::Editor::Lines]
+      def self.coerce(document)
+        if document.is_a?(self)
+          new(document.lines)
+
+        elsif document.is_a?(Array)
+          lines = document.map do |line|
+            if line.is_a?(Vedeu::Editor::Line)
+              line
+
+            elsif line.is_a?(String)
+              Vedeu::Editor::Line.coerce(line)
+
+            else
+              Vedeu::Editor::Line.new
+
+            end
+          end
+
+          new(lines)
+
+        elsif document.is_a?(String)
+          lines = document.lines.map(&:chomp).map do |line|
+            Vedeu::Editor::Line.coerce(line)
+          end
+
+          new(lines)
+
+        else
+          new
+
+        end
+      end
+
+      # Returns a new instance of Vedeu::Editor::Lines.
+      #
+      # @param lines [Array<String>|NilClass]
+      # @return [Vedeu::Editor::Lines]
+      def initialize(lines = nil)
+        @lines = lines || []
+      end
+
+      # Return a line or collection of lines (if index is a Range).
+      #
+      # @param index [Fixnum|Range]
+      # @return [Vedeu::Editor::Line]
+      def [](index)
+        lines[index]
+      end
+
+      # Deletes the character from the line where the cursor is currently
+      # positioned.
+      #
+      # @param y [Fixnum]
+      # @param x [Fixnum]
+      # @return [Vedeu::Editor::Lines]
+      def delete_character(y, x)
+        lines[y] = line(y).delete_character(x)
+        Vedeu::Editor::Lines.coerce(lines)
+      end
+
+      # Delete the line from the lines positioned at the given index.
+      #
+      # @param index [Fixnum|NilClass]
+      # @return [String]
+      def delete_line(index = nil)
+        return self if lines.empty? || (index && index <= 0)
+
+        new_lines = if index && index <= size
+                      lines.dup.tap { |lines| lines.slice!(index) }
+
+                    else
+                      lines.dup.tap(&:pop)
+
+                    end
+
+        Vedeu::Editor::Lines.coerce(new_lines)
+      end
+
+      # Provides iteration over the collection.
+      #
+      # @param block [Proc]
+      # @return [Enumerator]
+      def each(&block)
+        lines.each(&block)
+      end
+
+      # Returns a boolean indicating whether there are lines.
+      #
+      # @return [Boolean]
+      def empty?
+        size == 0
+      end
+
+      # An object is equal when its values are the same.
+      #
+      # @param other [Vedeu::Editor::Lines]
+      # @return [Boolean]
+      def eql?(other)
+        self.class == other.class && lines == other.lines
+      end
+      alias_method :==, :eql?
+
+      # Insert a character in to a line.
+      #
+      # @param character [String]
+      # @param y [Fixnum]
+      # @param x [Fixnum]
+      # @return [Vedeu::Editor::Lines]
+      def insert_character(character, y, x)
+        lines[y] = line(y).insert_character(character, x)
+        Vedeu::Editor::Lines.coerce(lines)
+      end
+
+      # Insert the line on the line below the given index.
+      #
+      # @param line [String]
+      # @param index [Fixnum|NilClass]
+      # @return [Vedeu::Editor::Lines]
+      def insert_line(line, index = nil)
+        return self unless line
+
+        new_lines = if index
+                      if index <= 0
+                        lines.insert(0, line)
+
+                      elsif index >= size
+                        lines << line
+
+                      else
+                        lines.insert(index, line)
+
+                      end
+                    else
+                      lines << line
+
+                    end
+
+        Vedeu::Editor::Lines.coerce(new_lines)
+      end
+
+      # Returns the line at the given index.
+      #
+      # @param index [Fixnum|NilClass]
+      # @return [Vedeu::Editor::Line]
+      def line(index = nil)
+        return Vedeu::Editor::Line.new                unless lines
+        return Vedeu::Editor::Line.coerce(lines.last) unless index
+
+        indexed = if index <= 0
+                    lines.first
+
+                  elsif index && index <= size
+                    lines[index]
+
+                  else
+                    lines.last
+
+                  end
+
+        Vedeu::Editor::Line.coerce(indexed)
+      end
+
+      # Return the number of lines.
+      #
+      # @return [Fixnum]
+      def size
+        lines.size
+      end
+
+      # Return the lines as a string.
+      #
+      # @return [String]
+      def to_s
+        lines.map(&:to_s).join
+      end
+
+    end # Line
+
+  end # Editor
+
+end # Vedeu