yap-rawline 0.1.0

data/lib/rawline/event_loop.rb

@@ -0,0 +1,78 @@
+module RawLine
+  class EventLoop
+    attr_reader :events
+
+    def initialize(registry:)
+      @registry = registry
+      @events = []
+    end
+
+    # event looks like:
+    #  * name
+    #  * source
+    #  * target
+    #  * payload
+    def add_event(**event)
+      # if the last event is the same as the incoming then do there is no
+      # need to add it again. For example, rendering events that already
+      # back can be squashed into a single event.
+      if @events.last != event
+        @events << event
+      end
+    end
+
+    def recur(event:nil, interval_in_ms:, &blk)
+      if block_given?
+        # TODO: implement
+      elsif event
+        add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) })
+      else
+        raise "Must pass in a block or an event."
+      end
+    end
+
+    def start
+      loop do
+        event = @events.shift
+        if event
+          recur = event[:recur]
+          if recur
+            if current_time_in_ms >= recur[:recur_at]
+              dispatch_event(event)
+              interval_in_ms = recur[:interval_in_ms]
+              add_event event.merge(recur: { interval_in_ms: interval_in_ms, recur_at: recur_at(interval_in_ms) } )
+            else
+              # put it back on the queue
+              add_event event
+              dispatch_event(default_event)
+            end
+          else
+            dispatch_event(event)
+          end
+        else
+          dispatch_event(default_event)
+        end
+      end
+    end
+
+    private
+
+    def current_time_in_ms
+      (Time.now.to_f * 1_000).to_i
+    end
+
+    def default_event
+      { name: 'default', source: self }
+    end
+
+    def recur_at(interval_in_ms)
+      current_time_in_ms + interval_in_ms
+    end
+
+    def dispatch_event(event)
+      @registry.subscribers_for_event(event[:name]).each do |subscriber|
+        subscriber.call(event)
+      end
+    end
+  end
+end

data/lib/rawline/event_registry.rb

@@ -0,0 +1,17 @@
+module RawLine
+  class EventRegistry
+    def initialize(&blk)
+      @subscribers = Hash.new{ |h,k| h[k.to_sym] = [] }
+      blk.call(self) if block_given?
+    end
+
+    def subscribe(event_name, *subscribers, &blk)
+      subscribers << blk if block_given?
+      @subscribers[event_name.to_sym].concat(subscribers)
+    end
+
+    def subscribers_for_event(event_name)
+      @subscribers[event_name.to_sym]
+    end
+  end
+end

data/lib/rawline/history_buffer.rb

@@ -0,0 +1,177 @@
+#!usr/bin/env ruby
+
+#
+#  history_buffer.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+#
+#
+module RawLine
+
+  #
+  # The HistoryBuffer class is used to hold the editor and line histories, as well
+  # as word completion matches.
+  #
+  class HistoryBuffer < Array
+
+    attr_reader :position, :size
+    attr_accessor :duplicates, :exclude, :cycle
+
+    #
+    # Create an instance of RawLine::HistoryBuffer.
+    # This method takes an optional block used to override the
+    # following instance attributes:
+    # * <tt>@duplicates</tt> - whether or not duplicate items will be stored in the buffer.
+    # * <tt>@exclude</tt> - a Proc object defining exclusion rules to prevent items from being added to the buffer.
+    # * <tt>@cycle</tt> - Whether or not the buffer is cyclic.
+    #
+    def initialize(size)
+      @duplicates = true
+      @exclude = lambda{|a|}
+      @cycle = false
+      yield self if block_given?
+      @size = size
+      @position = nil
+    end
+
+    #
+    # Clears the current position on the history object. Useful when deciding
+    # to cancel/reset history navigation.
+    #
+    def clear_position
+      @position = nil
+    end
+
+    def searching?
+      !!@position
+    end
+
+    def supports_partial_text_matching?
+      false
+    end
+
+    #
+    # Resize the buffer, resetting <tt>@position</tt> to nil.
+    #
+    def resize(new_size)
+      if new_size < @size
+        @size-new_size.times { pop }
+      end
+      @size = new_size
+      @position = nil
+    end
+
+    #
+    # Clear the content of the buffer and reset <tt>@position</tt> to nil.
+    #
+    def empty
+      @position = nil
+      clear
+    end
+
+    #
+    # Retrieve a copy of the element at <tt>@position</tt>.
+    #
+    def get
+      return nil unless length > 0
+      return nil unless @position
+      at(@position).dup
+    end
+
+    #
+    # Return true if <tt>@position</tt> is at the end of the buffer.
+    #
+    def end?
+      @position == length-1
+    end
+
+    #
+    # Return true if <tt>@position</tt> is at the start of the buffer.
+    #
+    def start?
+      @position == 0
+    end
+
+    #
+    # Decrement <tt>@position</tt>. By default the history will become
+    # positioned at the previous item.
+    #
+    # If <tt>@cycle</tt> is set to true then the history will cycle to the end
+    # when it finds itself at the beginning. If false calling this when
+    # at the beginning will result in the position not changing.
+    #
+    # If a search strategy is assigned then the method <tt>search_backward</tt> will be
+    # called on the search strategy to determine the position. This method is
+    # given any passed in <tt>options</tt> as well as a <tt>:history</tt> option. The
+    # <tt>:history</tt> option will be a reference to self.
+    #
+    def back(options={})
+      return nil unless length > 0
+
+      case @position
+      when nil then
+        @position = length-1
+      when 0 then
+        @position = length-1 if @cycle
+      else
+        @position -= 1
+      end
+    end
+
+    #
+    # Increment <tt>@position</tt>. By default the history will become
+    # positioned at the next item.
+    #
+    # If <tt>@cycle</tt> is set to true then the history will cycle back to the
+    # beginning when it finds itself at the end. If false calling this when
+    # at the end will result in the position not changing.
+    #
+    # If a search strategy is assigned then the method <tt>search_forward</tt> will be
+    # called on the search strategy to determine the position. This method is
+    # given any passed in <tt>options</tt> as well as a <tt>:history</tt> option. The
+    # <tt>:history</tt> option will be a reference to self. If <tt>
+    #
+    def forward(options={})
+      return nil unless length > 0
+
+      case @position
+      when nil then
+        nil
+      when length-1 then
+        @position = 0 if @cycle
+      else
+        @position += 1
+      end
+    end
+
+    #
+    # Add a new item to the buffer.
+    #
+    def push(item)
+
+      if !@duplicates && self[-1] == item
+        # skip adding this line
+        return
+      end
+
+      unless @exclude.call(item)
+        # Remove the oldest element if size is exceeded
+        if @size <= length
+          reverse!.pop
+          reverse!
+        end
+        # Add the new item and reset the position
+        super(item)
+        @position = nil
+      end
+    end
+
+    alias << push
+
+  end
+
+end

data/lib/rawline/keycode_parser.rb

@@ -0,0 +1,49 @@
+module RawLine
+  class KeycodeParser
+    def initialize(keymap)
+      @keymap = keymap
+      @escape_code = keymap[:escape]
+    end
+
+    def parse_bytes(bytes)
+      i = 0
+      results = []
+      loop do
+        byte = bytes[i]
+
+        keycode = find_keycode_for_multi_byte_sequence(bytes[i..-1])
+        if keycode
+          results << keycode
+          i += keycode.length
+        else
+          results << byte.ord
+          i += 1
+        end
+
+        break if i >= bytes.length
+      end
+      results
+    end
+
+    private
+
+    # {:left_arrow=>[27, 91, 68]}
+    # [27, 91, 68]
+    def find_keycode_for_multi_byte_sequence(bytes)
+      i = 0
+      sequence = []
+      loop do
+        byte = bytes[i]
+        if @keymap.values.any?{ |arr| arr[i] == byte }
+          sequence << byte
+          i += 1
+        else
+          break
+        end
+        break if i >= bytes.length
+      end
+
+      sequence.any? ? sequence : nil
+    end
+  end
+end

data/lib/rawline/line.rb

@@ -0,0 +1,169 @@
+#!usr/bin/env ruby
+
+#
+#  line.rb
+#
+# Created by Fabio Cevasco on 2008-03-01.
+# Copyright (c) 2008 Fabio Cevasco. All rights reserved.
+#
+# This is Free Software.  See LICENSE for details.
+#
+
+module RawLine
+
+  #
+  # The Line class is used to represent the current line being processed and edited
+  # by RawLine::Editor. It keeps track of the characters typed, the cursor position,
+  # the current word and maintains an internal history to allow undos and redos.
+  #
+  class Line
+
+    attr_accessor :text, :position, :history, :prompt, :history_size, :word_separator
+    attr_reader :offset
+
+    include HighLine::SystemExtensions
+
+    #
+    # Create an instance of RawLine::Line.
+    # This method takes an optional block used to override the
+    # following instance attributes:
+    # * <tt>@text</tt> - the line text.
+    # * <tt>@history_size</tt> - the size of the line history buffer.
+    # * <tt>@position</tt> - the current cursor position within the line.
+    # * <tt>@prompt</tt> - a prompt to prepend to the line text.
+    #
+    def initialize(history_size)
+      @text = ANSIString.new("")
+      @history_size = history_size
+      @position = 0
+      @prompt = ""
+      @word_separator = ' '
+      yield self if block_given?
+      @history = RawLine::HistoryBuffer.new(@history_size)
+      @history << "" # Add empty line for complete undo...
+      @offset = @prompt.length
+    end
+
+    #
+    # Return the maximum line length. By default, it corresponds to the terminal's
+    # width minus the length of the line prompt.
+    #
+    def max_length
+      terminal_size[0]-@offset
+    end
+
+    #
+    # Return information about the current word, as a Hash composed by the following
+    # elements:
+    # * <tt>:start</tt>: The position in the line corresponding to the word start
+    # * <tt>:end</tt>: The position in the line corresponding to the word end
+    # * <tt>:text</tt>: The word text.
+    def word
+      return {:start => bol, :end => eol+1, :text => @text} if @word_separator.to_s == ''
+      last = @text.index(@word_separator, @position)
+      first = @text.rindex(@word_separator, @position)
+      # Trim word separators and handle EOL and BOL
+      if first then
+         first +=1
+      else
+        first = bol
+      end
+      if last then
+         last -=1
+      else
+        last = eol+1 unless last
+      end
+      # Swap if overlapping
+      last, first = first, last if last < first
+      text = @text[first..last].to_s
+      # Repeat the search if within word separator
+      if text.match @word_separator then
+        last = first
+        first = @text.rindex(@word_separator, first)
+         if first then first+=1
+        else first =  bol
+        end
+        text = @text[first..last]
+      end
+      {:start => first, :end => last, :text => text}
+    end
+
+    #
+    # Return an array containing the words present in the current line
+    #
+    def words
+      @text.split @word_separator
+    end
+
+    #
+    # Return the position corresponding to the beginning of the line.
+    #
+    def bol
+     0
+    end
+
+    #
+    # Return true if the cursor is at the beginning of the line.
+    #
+    def bol?
+      @position<=bol
+    end
+
+    #
+    # Return the position corresponding to the end of the line.
+    #
+    def eol
+      @text.length-1
+    end
+
+    #
+    # Return true if the cursor is at the end of the line.
+    #
+    def eol?
+      @position>=eol
+    end
+
+    #
+    # Decrement the line position by <tt>offset</tt>
+    #
+    def left(offset=1)
+      @position = (@position-offset <= 0) ? 0 : @position-offset
+    end
+
+    #
+    # Increment the line position by <tt>offset</tt>
+    #
+    def right(offset=1)
+      @position += offset
+    end
+
+    #
+    # Add a character (expressed as a character code) to the line text.
+    #
+    def <<(char)
+      @text << char.chr
+    end
+
+    #
+    # Access the line text at <tt>@index</tt>
+    #
+    def [](index)
+      @text[index]
+    end
+
+    #
+    #  Modify the character(s) in the line text at <tt>@index</tt>
+    #
+    def []=(index, chars)
+      @text[index] = chars
+    end
+
+    #
+    # Return the length of the line text.
+    #
+    def length
+      @text.length
+    end
+
+  end
+end