yap-rawline 0.6.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fc89446c1a7d8c2867d80966385bd4440afd881
-  data.tar.gz: 035306deacfd89d6e45a6892718bb241e8db8966
+  metadata.gz: 92c874a27903902d286dbf30ed5a9650766b09cd
+  data.tar.gz: b88b897fd79df0714fe681765296577e617189ad
 SHA512:
-  metadata.gz: a6b3bdf5587d883b255aa70875f717ac411cb2189db1b42eb1c815cf29bef09a52679f9293bf0794a8bbe67dba83d05a6ef2332676c3ed9a38c700a259568d92
-  data.tar.gz: 661bad9b1aa6eb3df3fbadd57ba7f9a4c61087fbdf839019e503269def8ab309a5d2e95674e03da004175e2e97e876e29d9be43d246847c80ca65d641a21cc48
+  metadata.gz: 8356ff5e616f22d71c360271c16b54b17ae431d3473f22b5105894ab605d05c88d308bde5cbf2eeffa596f702aa4e8eb62cceda6cba858717a420ea7c64b5e1f
+  data.tar.gz: 2d07d64f41788cd96655f2b227e4361f727ce9b393b3473633c06ab51a0e05604bc5920c79fb9060ac233c2af7866fd9974f5835abd94a5532c85a98f700dfe9

data/lib/rawline/completer.rb

@@ -11,11 +11,10 @@ module RawLine
       @done_proc = done
       @keys = keys
 
-      @completion_matches = HistoryBuffer.new(0) do |h|
-        h.duplicates = false
-        h.cycle = true
-      end
-      @completion_matches.empty
+      @completion_matches = HistoryBuffer.new_with_infinite_size(
+        cycle: true,
+        duplicates: false
+      )
 
       @first_time = true
       @word_start = @line.word[:start]
@@ -30,7 +29,8 @@ module RawLine
 
       if @first_time
         matches = fetch_completions
-        resize(matches)
+        @completion_matches.replace(matches)
+        @completion_matches.first!
 
         if matches.length == 1
           handle_one_match
@@ -77,7 +77,7 @@ module RawLine
 
     def handle_one_match
       Treefell['editor'].puts "completer, exactly one possible completion found: #{@completion_matches.inspect}"
-      @completion_selected_proc.call(@completion_matches.first)
+      @completion_selected_proc.call(@completion_matches.get)
 
       Treefell['editor'].puts "completer, done"
       @done_proc.call
@@ -85,9 +85,6 @@ module RawLine
 
     def handle_more_than_one_match
       Treefell['editor'].puts "completer, more than one possible completion"
-
-      # Get first match
-      @completion_matches.forward
       match = @completion_matches.get
 
       Treefell['editor'].puts "completer: first completion: #{match} possible: #{@completion_matches.inspect}"
@@ -102,13 +99,6 @@ module RawLine
       @done_proc.call
     end
 
-    def resize(matches)
-      if matches.any?
-        @completion_matches.resize(matches.length)
-        matches.each { |w| @completion_matches << w }
-      end
-    end
-
     def select_next
       @completion_matches.forward
       match = @completion_matches.get

data/lib/rawline/editor.rb

@@ -213,17 +213,17 @@ module RawLine
 
       Signal.trap("SIGWINCH") do
         Treefell['editor'].puts "terminal-resized trap=SIGWINCH"
-        @event_loop.add_event name: "terminal-resized", source: self
+        @event_loop.add_event name: "terminal-resized"
       end
 
       @event_registry.subscribe("terminal-resized") do
         width, height = terminal_width, terminal_height
         Treefell['editor'].puts "terminal-resizing width=#{width} height=#{height}"
         @renderer.update_dimensions(width: width, height: height)
-        @event_loop.add_event name: "render", source: self
+        @event_loop.add_event name: "render"
       end
 
-      @event_loop.add_event name: "render", source: self
+      @event_loop.add_event name: "render"
       @event_loop.start
     end
 
@@ -248,7 +248,7 @@ module RawLine
       if bytes.any?
         keyboard_input_processor.read_bytes(bytes)
       end
-      @event_loop.add_event name: 'check_for_keyboard_input', source: self
+      @event_loop.add_event name: 'check_for_keyboard_input'
     end
 
     def read_bytes(bytes)
@@ -266,20 +266,17 @@ module RawLine
           if @char == @terminal.keys[:enter] || !@char
             Treefell['editor'].puts "processing line: #{@line.text.inspect}"
 
-            @renderer.pause
-            process_line
+            @renderer.rollup { process_line }
           else
             process_character
             new_position = @line.position
           end
         end
-      ensure
-        @renderer.unpause
       end
     end
 
     def process_line
-      @event_loop.immediately(name: "process_line", source: self) do
+      @event_loop.immediately(name: "process_line") do
         add_to_history
 
         @terminal.snapshot_tty_attrs
@@ -288,14 +285,14 @@ module RawLine
         @terminal.move_to_beginning_of_row
         @terminal.puts
       end
-      @event_loop.immediately(name: "line_read", source: self, payload: { line: @line.text.without_ansi.dup })
-      @event_loop.immediately(name: "prepare_new_line", source: self) do
+      @event_loop.immediately(name: "line_read", payload: { line: @line.text.without_ansi.dup })
+      @event_loop.immediately(name: "prepare_new_line") do
         history.clear_position
         reset_line
         move_to_beginning_of_input
       end
-      @event_loop.immediately(name: "restore_tty_attrs", source: self) { @terminal.restore_tty_attrs }
-      @event_loop.immediately(name: "render", source: self, payload: { reset: true })
+      @event_loop.immediately(name: "restore_tty_attrs") { @terminal.restore_tty_attrs }
+      @event_loop.immediately(name: "render", payload: { reset: true  })
     end
 
     #
@@ -833,7 +830,7 @@ module RawLine
 
       @dom.on(:content_changed) do |*args|
         Treefell['editor'].puts 'DOM content changed, re-rendering'
-        @event_loop.add_event name: "render"
+        @event_loop.immediately name: "render"
       end
 
       @dom.on(:child_changed) do |*args|
@@ -843,7 +840,7 @@ module RawLine
 
       @dom.on :position_changed do |*args|
         Treefell['editor'].puts 'DOM position changed, rendering cursor'
-        @renderer.render
+        @renderer.render_cursor
       end
 
       @dom.on :focus_changed do |*args|

data/lib/rawline/event_loop.rb

@@ -10,7 +10,6 @@ module RawLine
 
     # event looks like:
     #  * name
-    #  * source
     #  * target
     #  * payload
     def add_event(**event, &blk)
@@ -18,6 +17,10 @@ module RawLine
         event[:_event_callback] = blk if blk
       end
 
+      unless event.has_key?(:_event_caller)
+        event[:_event_caller] = caller[0..5]
+      end
+
       unless event.has_key?(:_event_id)
         @counter += 1
         event[:_event_id] = @counter
@@ -39,7 +42,7 @@ module RawLine
     end
 
     def immediately(**event_kwargs, &blk)
-      dispatch_event(event_kwargs.merge(_event_callback: blk))
+      dispatch_event(event_kwargs.merge(_event_callback: blk, _event_caller: caller[0..5]))
     end
 
     def reset
@@ -100,7 +103,7 @@ module RawLine
     end
 
     def default_event
-      { name: 'default', source: self, _event_id: -1 }
+      { name: 'default', _event_id: -1 }
     end
 
     def recur_at(interval_in_ms)

data/lib/rawline/history_buffer.rb

@@ -16,124 +16,171 @@ module RawLine
   # The HistoryBuffer class is used to hold the editor and line histories, as well
   # as word completion matches.
   #
-  class HistoryBuffer < Array
+  class HistoryBuffer
+    DefaultSize = 1024
+    Infinity = 1.0 / 0
 
-    attr_reader :position, :size
-    attr_accessor :duplicates, :exclude, :cycle
+    # +size+ is used to determine how many history items should be kept.
+    attr_reader :size
+
+    # +duplicates+ is used to determine if the history can house duplicate \
+    # items, consecutively
+    attr_accessor :duplicates
+
+    # +exclude+ can be set to a lambda/proc filter to determine
+    # if an item should be excluded from the history
+    attr_accessor :exclude
+
+    # +cycle+ is used to determine if the the buffer is cyclic
+    attr_accessor :cycle
+
+    # +position+ can be used to set or get the current location of the history
+    attr_accessor :position
+
+    def self.new_with_infinite_size(**kwargs)
+      new(Infinity, **kwargs)
+    end
 
     #
     # 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
-
+    # following properties:
     #
-    # Clears the current position on the history object. Useful when deciding
-    # to cancel/reset history navigation.
+    # * <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 clear_position
+    def initialize(size=DefaultSize, cycle: false, duplicates: true, exclude: nil)
+      @history = []
+      @duplicates = duplicates
+      @exclude = exclude || -> (item){ }
+      @cycle = cycle
+      yield self if block_given?
+      @size = size && size > 0 ? size : DefaultSize
       @position = nil
     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
+    def [](index)
+      @history[index]
     end
 
-    def find_match_backward(text)
-      regex = to_regex(text)
-      offset = @position ? length - position : 0
-      reverse[offset..-1].detect.with_index do |item, index|
-        if item.match(regex)
-          @position = length - index - (offset + 1)
-        end
-      end
+    def any?(&blk)
+      @history.any?(&blk)
     end
 
-    def find_match_forward(text)
-      regex = to_regex(text)
-      offset = @position ? @position + 1 : 0
-      self[offset..-1].detect.with_index do |item, index|
-        if item.match(regex)
-          @position = index + offset
-        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
 
     #
-    # Clear the content of the buffer and reset <tt>@position</tt> to nil.
+    # Clear the content of the buffer and resets <tt>position</tt> to nil.
     #
-    def empty
+    def clear
       @position = nil
-      clear
+      @history.clear
     end
 
     #
-    # Retrieve a copy of the element at <tt>@position</tt>.
+    # Clears the current position on the history object. Useful when deciding
+    # to cancel/reset history navigation.
     #
-    def get
-      return nil unless length > 0
-      @position = length-1 unless @position
-      at(@position).dup
+    def clear_position
+      @position = nil
+    end
+
+    def detect(&blk)
+      @history.detect(&blk)
+    end
+
+    def each(&blk)
+      @history.each(&blk)
+    end
+
+    # Return true if the history is empty, otherwise false.
+    def empty?
+      @history.empty?
     end
 
     #
     # Return true if <tt>@position</tt> is at the end of the buffer.
     #
     def end?
-      @position == length-1
+      @position == length - 1
     end
 
     #
-    # Return true if <tt>@position</tt> is at the start of the buffer.
+    # Override equals check. Will be the same as another HistoryBuffer
+    # object with the same history items. Ignores position, exclusion filter,
+    # and so on.
     #
-    def start?
-      @position == 0
+    def ==(other)
+      other.is_a?(self.class) &&
+        other.instance_variable_get(:@history) == @history
     end
 
     #
-    # Decrement <tt>@position</tt>. By default the history will become
-    # positioned at the previous item.
+    # Finds and returns the first item matching the given text, starting
+    # from the current <tt>position</tt>, moving backwards. The given text
+    # will be successfully matched if it matches any part of a history 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.
+    def find_match_backward(text)
+      regex = to_regex(text)
+      @position = nil if @position == 0 && @cycle
+      offset = @position ? length - position : 0
+      @history.reverse[offset..-1].detect.with_index do |item, index|
+        if item.match(regex)
+          @position = length - index - (offset + 1)
+        end
+      end
+    end
+
     #
-    # 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.
+    # Finds and returns the first item matching the given text, starting
+    # from the current <tt>position</tt>, moving forwards. The given text
+    # will be successfully matched if it matches any part of a history item.
     #
-    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
+    def find_match_forward(text)
+      regex = to_regex(text)
+      @position = -1 if @position == length - 1 && @cycle
+      offset = @position ? @position + 1 : 0
+      @history[offset..-1].detect.with_index do |item, index|
+        if item.match(regex)
+          @position = index + offset
+        end
       end
     end
 
+    def first
+      @history.first
+    end
+
+    def first!
+      @position = 0
+      get
+    end
+
     #
     # Increment <tt>@position</tt>. By default the history will become
     # positioned at the next item.
@@ -152,7 +199,7 @@ module RawLine
 
       case @position
       when nil then
-        @position = 0
+        @position = length - 1
       when length-1 then
         @position = 0 if @cycle
       else
@@ -160,29 +207,110 @@ module RawLine
       end
     end
 
+    #
+    # Retrieve a copy of the history item at the current <tt>position</tt>.
+    #
+    def get
+      return nil unless length > 0
+      @position = length - 1 unless @position
+      @history.at(@position).dup
+    end
+
+    #
+    # Returns the index of the given item if it exists in the history,
+    # otherwise nil.
+    #
+    def index(item)
+      @history.index(item)
+    end
+
+    #
+    # Retrieve a copy of the last history item
+    #
+    def last
+      return nil unless @history.last
+      @history.last.dup
+    end
+
+    #
+    # Returns the number of items in the HistoryBuffer.
+    #
+    def length
+      @history.length
+    end
+
+    def map(&blk)
+      @history.map(&blk)
+    end
+
     #
     # Add a new item to the buffer.
     #
     def push(item)
-      if !@duplicates && include?(item)
+      if !@duplicates && last == item
         # skip adding this line
-        return
+        return self
       end
 
       unless @exclude.call(item)
         # Remove the oldest element if size is exceeded
         if @size <= length
-          reverse!.pop
-          reverse!
+          @history.reverse!.pop
+          @history.reverse!
         end
         # Add the new item and reset the position
-        super(item)
+        @history.push item
         @position = nil
       end
+      self
     end
-
     alias << push
 
+    #
+    # Replaces the current history with the given <tt>new_history</tt>. The
+    # new_history can be given as an array of history items or a HistoryBuffer
+    # object.
+    def replace(new_history)
+      if new_history.is_a?(HistoryBuffer)
+        new_history = new_history.instance_variable_get(:@history)
+      end
+      @history.replace(new_history)
+    end
+
+    #
+    # Resize the buffer, resetting <tt>position</tt> to nil.
+    #
+    def resize(new_size)
+      if new_size < length
+        (length - new_size).times { @history.shift }
+      end
+      @size = new_size
+      @position = nil
+      self
+    end
+
+    def reverse
+      self.class.new(size).tap do |new_history|
+        @history.reverse.each do |item|
+          new_history << item
+        end
+      end
+    end
+
+    #
+    # Return true if <tt>position</tt> is at the start of the buffer.
+    #
+    def beginning?
+      @position == 0
+    end
+
+    #
+    # Returns a copy of the HistoryBuffer as an array.
+    #
+    def to_a
+      @history.dup
+    end
+
     private
 
     def to_regex(text)