fatty 0.99.0 → 0.99.3

data/lib/fatty/input_field.rb

@@ -20,14 +20,14 @@ module Fatty
   #
   #   Word-motion and word-deletion semantics are delegated to InputBuffer so
   #   the definition of "word" can be configured in one place (via
-  #   =InputBuffer='s word_chars/word_re).
+  #   =InputBuffer='s word_char_re).
   class InputField
     include Actionable
 
     attr_reader :buffer, :prompt, :history
 
     def initialize(
-      prompt:,
+      prompt: ">",
       buffer: nil,
       completion_proc: nil,
       history: nil,
@@ -39,17 +39,15 @@ module Fatty
       @history_kind = history_kind
       @history_ctx = history_ctx
       @completion_proc = completion_proc
-      @completion_cycle_base = nil
-      @completion_cycle_candidates = []
-      @completion_cycle_index = nil
+      @completion_state = nil
 
       @buffer =
         if buffer
           buffer
         else
           cfg = Fatty::Config.config
-          word_chars = cfg.dig(:input_buffer, :word_chars) || Fatty::InputBuffer::DEFAULT_WORD_CHARS
-          Fatty::InputBuffer.new(word_chars: word_chars)
+          word_char_re = cfg.dig(:word_char_re) || Fatty::InputBuffer::DEFAULT_WORD_CHAR_RE
+          Fatty::InputBuffer.new(word_char_re: word_char_re)
         end
     end
 
@@ -66,52 +64,31 @@ module Fatty
       buffer.text == ""
     end
 
-    # Visual cursor X position in the window
-    def cursor_x
-      before_cursor = buffer.text.to_s[0...buffer.cursor].to_s
-      prompt_width + Fatty::Ansi.visible_length(before_cursor)
-    end
-
-    def prompt_text
-      prompt.text
-    end
-
-    # The prompt might use coloring, so we use the visible length stripped of
-    # ANSI controls.
-    def prompt_width
-      Fatty::Ansi.visible_length(prompt_text.to_s.lines.last.to_s)
-    end
-
-    def snapshot_input_state
+    def state
       [
         prompt_text.to_s.dup.freeze,
         buffer.text.to_s.dup.freeze,
+        buffer.cursor,
         buffer.virtual_suffix.to_s.dup.freeze,
-        cursor_x,
-        (r = buffer.region_range) ? [r.begin, r.end] : nil,
+        buffer.region_active?,
+        buffer.region_range,
       ]
     end
 
-    # :category: Setters
-
-    def prompt=(prompt)
-      @prompt = Prompt.ensure(prompt)
-    end
-
     # :category: Actions
 
     desc "Accept the current line, add to history, and clear the buffer"
-    action :accept_line do
+    action :accept_line do |save_history: true|
       line = buffer.text.dup
-      if history
+      if save_history && history && !line.empty?
         history.add(
           line,
           kind: resolve_history_kind,
           ctx: resolve_history_ctx,
         )
-        buffer.clear
-        line
       end
+      buffer.clear
+      line
     end
 
     desc "Replace buffer with the previous history entry"
@@ -136,6 +113,101 @@ module Fatty
       buffer.insert(s)
     end
 
+    def autosuggestion
+      active = active_completion_autosuggestion
+      return active if active
+
+      text = buffer.text.to_s
+      return if text.empty?
+
+      autosuggestion_candidates.first
+    end
+
+    def complete!(direction: 1)
+      candidates = tab_completion_candidates
+      common_prefix = common_completion_prefix(candidates)
+
+      if candidates.length == 1
+        accept_completion_line(candidates.first)
+      elsif direction.positive? &&
+            common_prefix &&
+            common_prefix.length > buffer.text.length
+        accept_completion_line(common_prefix)
+      else
+        cycle_completion!(direction: direction)
+      end
+    end
+
+    def cycle_completion!(direction: 1)
+      text = buffer.text.to_s
+      candidates = tab_completion_candidates
+      result = nil
+
+      if candidates.empty?
+        reset_completion_state!
+      elsif same_completion_state?(base: text, candidates: candidates)
+        @completion_state[:index] =
+          (@completion_state[:index] + direction) % @completion_state[:candidates].length
+        result = @completion_state[:candidates][@completion_state[:index]]
+      else
+        @completion_state = {
+          base: text,
+          candidates: candidates,
+          index: 0,
+        }
+        result = @completion_state[:candidates].first
+      end
+
+      sync_virtual_suffix!
+      result
+    end
+
+    def popup_completion_candidates
+      path_prefix = popup_path_completion_prefix
+      if path_prefix
+        path = rendered_path_candidates(path_prefix)
+        return path if path.any?
+      end
+      autosuggestion_candidates(base: buffer.text.to_s[0...buffer.cursor])
+    end
+
+    def path_completion_candidates
+      prefix = path_completion_prefix
+      return [] if prefix.nil? || prefix.empty?
+
+      rendered_path_candidates(prefix)
+    end
+
+    def path_completion_candidates_for(prefix)
+      return [] if prefix.nil? || prefix.empty?
+
+      rendered_path_candidates(prefix)
+    end
+
+    def popup_completion_range
+      if popup_path_completion_prefix
+        path_completion_range
+      else
+        0...buffer.text.length
+      end
+    end
+
+    def popup_completion_query
+      path_completion_prefix || buffer.completion_prefix
+    end
+
+    def popup_completion_path?
+      !!popup_path_completion_prefix
+    end
+
+    def reset_completion_state!
+      @completion_state = nil
+    end
+
+    def sync_virtual_suffix!
+      buffer.virtual_suffix = autosuggestion_suffix
+    end
+
     def act_on(action, *args, env: nil, **kwargs)
       return unless action
 
@@ -148,130 +220,147 @@ module Fatty
           defn = Fatty::Actions.lookup(action)
           target =
             case defn[:on]
-            when :field then self
             when :buffer then buffer
             else
               raise Fatty::ActionError, "Cannot dispatch #{action} without env for target #{defn[:on].inspect}"
             end
           target.public_send(defn[:method], *args, **kwargs)
         end
-      elsif buffer.respond_to?(action)
-        buffer.public_send(action, *args, **kwargs)
-      elsif respond_to?(action)
-        public_send(action, *args, **kwargs)
       else
         raise Fatty::ActionError, "Unknown action: #{action}"
       end
     end
 
-    # :category: Completion
+    def prompt_text
+      prompt.text
+    end
 
-    def autosuggestion
-      return if buffer.text.empty?
+    # Visual cursor X position in the window
+    def cursor_x
+      before_cursor = buffer.text.to_s[0...buffer.cursor].to_s
+      prompt_width + Fatty::Ansi.visible_length(before_cursor)
+    end
+
+    def prompt=(prompt)
+      @prompt = Prompt.ensure(prompt)
+    end
+
+    private
+
+    # simplecov:disable
+
+    def accept_completion_line(line)
+      return unless line
+
+      buffer.replace(line)
+      reset_completion_state!
+      buffer.virtual_suffix = ""
+      line
+    end
 
-      active_completion_autosuggestion || default_completion_autosuggestion || history_autosuggestion
+    # The prompt might use coloring, so we use the visible length stripped of
+    # ANSI controls.
+    def prompt_width
+      Fatty::Ansi.visible_length(prompt_text.to_s.lines.last.to_s)
     end
 
+    # :category: Completion
+
     def completion_candidates
       return [] unless @completion_proc
 
-      prefix = buffer.completion_prefix.to_s
-      return [] if prefix.empty?
-
       Array(@completion_proc.call(buffer))
         .compact
         .map(&:to_s)
         .reject(&:empty?)
-        .select { |s| s.start_with?(prefix) }
-        .reject { |s| s == prefix }
         .uniq
     end
 
+    def common_completion_prefix(candidates)
+      return if candidates.empty?
+
+      first, last = candidates.minmax
+      length = 0
+      limit = [first.length, last.length].min
+
+      length += 1 while length < limit && first[length] == last[length]
+      first[0...length]
+    end
+
     def completion_suggestions
-      raw =
-        if path_completion_candidates.any?
-          path_completion_candidates
-        else
-          completion_candidates
-        end
+      if path_completion_candidates.any?
+        path_completion_candidates
+          .map { |candidate| build_line_with_completion(candidate, range: path_completion_range) }
+          .reject { |line| line == buffer.text.to_s }
+          .uniq
+      else
+        completion_candidates
+          .map { |candidate| build_line_with_completion(candidate, range: completion_replace_range) }
+          .reject { |line| line == buffer.text.to_s }
+          .uniq
+      end
+    end
 
-      raw
-        .map { |candidate| build_line_with_completion(candidate) }
-        .reject { |line| line == buffer.text.to_s }
+    def autosuggestion_candidates(base: buffer.text.to_s)
+      (history_autosuggestions + completion_suggestions)
+        .compact
+        .map(&:to_s)
+        .select { |candidate| candidate.start_with?(base) }
+        .reject { |candidate| candidate == buffer.text.to_s }
         .uniq
     end
 
+    def tab_completion_candidates
+      path = path_completion_candidates
+      if path.any?
+        path.map { |candidate| build_line_with_completion(candidate, range: path_completion_range) }
+          .reject { |line| line == buffer.text.to_s }
+          .uniq
+      else
+        autosuggestion_candidates
+      end
+    end
+
     def default_completion_autosuggestion
-      suggestions = completion_suggestions
-      result = suggestions.first
-      result
+      completion_suggestions.first
     end
 
     def active_completion_autosuggestion
-      text = buffer.text.to_s
-      result = nil
+      return unless @completion_state
 
-      if @completion_cycle_base == text &&
-         @completion_cycle_index &&
-         !@completion_cycle_candidates.empty?
-        result = @completion_cycle_candidates[@completion_cycle_index]
+      text = buffer.text.to_s
+      if @completion_state[:base] == text &&
+         @completion_state[:index] &&
+         !@completion_state[:candidates].empty?
+        @completion_state[:candidates][@completion_state[:index]]
       end
-
-      result
     end
 
-    def cycle_completion!
+    def completion_replace_range
       text = buffer.text.to_s
-      suggestions = completion_suggestions
-      result = nil
+      cur = buffer.cursor.to_i
+      before = text[0...cur].to_s
 
-      if suggestions.empty?
-        reset_completion_cycle!
-      elsif @completion_cycle_base == text &&
-            @completion_cycle_candidates == suggestions &&
-            @completion_cycle_index
-        @completion_cycle_index = (@completion_cycle_index + 1) % @completion_cycle_candidates.length
-        result = @completion_cycle_candidates[@completion_cycle_index]
-      else
-        @completion_cycle_base = text
-        @completion_cycle_candidates = suggestions
-        @completion_cycle_index =
-          if suggestions.length > 1
-            1
-          else
-            0
-          end
-        result = @completion_cycle_candidates[@completion_cycle_index]
-      end
+      token = before[/\S+\z/].to_s
+      start = cur - token.length
 
-      sync_virtual_suffix!
-      result
+      start...cur
     end
 
-    def reset_completion_cycle!
-      @completion_cycle_base = nil
-      @completion_cycle_candidates = []
-      @completion_cycle_index = nil
-      nil
+    def completion_prefix
+      text[0...cursor].to_s[/\S+\z/].to_s
     end
 
-    def history_autosuggestion
-      return if history.nil?
+    def history_autosuggestions
+      return [] if history.nil?
 
-      history.suggest_for(
+      history.suggestions_for(
         resolve_history_kind,
         prefix: buffer.text,
         ctx: resolve_history_ctx,
       )
     end
 
-    def path_completion_candidates
-      prefix = path_completion_prefix
-      return [] if prefix.nil? || prefix.empty?
-
-      rendered_path_candidates(prefix)
-    end
-
     def path_like_prefix?(prefix)
       s = prefix.to_s
       return false if s.empty?
@@ -403,16 +492,21 @@ module Fatty
       end
     end
 
-    def build_line_with_completion(completion)
-      current = buffer.text.to_s
-      target = path_completion_range || buffer.completion_replace_range
-      start_i = target.begin
-      end_i   = target.end
-
-      before = current[0...start_i].to_s
-      after  = current[end_i..].to_s
+    def build_line_with_completion(candidate, range:)
+      text = buffer.text.to_s
+      before = text[0...range.begin].to_s
+      current = text[range].to_s
+      after = text[range.end..].to_s
+      candidate = candidate.to_s
+
+      replacement =
+        if !current.empty? && candidate.downcase.start_with?(current.downcase)
+          "#{current}#{candidate[current.length..]}"
+        else
+          candidate
+        end
 
-      "#{before}#{completion}#{after}"
+      "#{before}#{replacement}#{after}"
     end
 
     def autosuggestion_visible?
@@ -437,22 +531,6 @@ module Fatty
       buffer.accept_virtual_suffix!
     end
 
-    def popup_completion_candidates
-      path_prefix = popup_path_completion_prefix
-      if path_prefix
-        path = rendered_path_candidates(path_prefix)
-        return path if path.any?
-      end
-
-      return [] unless @completion_proc
-
-      Array(@completion_proc.call(buffer))
-        .compact
-        .map(&:to_s)
-        .reject(&:empty?)
-        .uniq
-    end
-
     def popup_path_completion_prefix
       prefix = path_completion_prefix
       return if prefix.nil? || prefix.empty?
@@ -468,24 +546,13 @@ module Fatty
       end
     end
 
-    def popup_completion_query
-      popup_path_completion_prefix || path_completion_prefix || buffer.completion_prefix
-    end
-
-    def popup_completion_range
-      path_completion_range || buffer.completion_replace_range
+    def same_completion_state?(base:, candidates:)
+      @completion_state &&
+        @completion_state[:base] == base &&
+        @completion_state[:candidates] == candidates &&
+        @completion_state[:index]
     end
 
-    def popup_completion_query
-      path_completion_prefix || buffer.completion_prefix
-    end
-
-    def sync_virtual_suffix!
-      buffer.virtual_suffix = autosuggestion_suffix
-    end
-
-    private
-
     def reset_history_cursor_for(action)
       return if action.to_s.start_with?("history_")
 

data/lib/fatty/key_event.rb

@@ -84,18 +84,10 @@ module Fatty
       !key.is_a?(Symbol)
     end
 
-    def bindings
-      Fatty::KeyMap.active.bindings_for(self) || {}
-    end
-
     def unbound?
       coded? && bindings.empty?
     end
 
-    def key_name
-      coded? ? to_s : "(none)"
-    end
-
     def code
       case raw
       when Integer
@@ -109,6 +101,68 @@ module Fatty
       bytes_from_raw(raw)
     end
 
+    def color
+      if uncoded?
+        :error
+      elsif unbound?
+        :warn
+      else
+        :good
+      end
+    end
+
+    def status_string
+      if uncoded?
+        "(UNCODED)"
+      elsif unbound?
+        "(UNBOUND)"
+      else
+        "(BOUND)"
+      end
+    end
+
+    def report
+      if uncoded?
+        report_for_uncoded
+      elsif unbound?
+        report_for_unbound
+      else
+        report_for_bound
+      end
+    end
+
+    def suggested_snippet(terminal_name)
+      if uncoded?
+        suggested_keydef(terminal_name)
+      elsif unbound?
+        suggested_keybinding
+      else
+        ''
+      end
+    end
+
+    def key_name
+      coded? ? to_s : "(none)"
+    end
+
+    def bindings
+      Fatty::KeyMap.active.bindings_for(self) || {}
+    end
+
+    def ctrl?
+      @ctrl
+    end
+
+    def meta?
+      @meta
+    end
+
+    def shift?
+      @shift
+    end
+
+    private
+
     def bytes_from_raw(value)
       case value
       when Array
@@ -181,48 +235,6 @@ module Fatty
       name.split("::").last
     end
 
-    def color
-      if uncoded?
-        :oops
-      elsif unbound?
-        :warn
-      else
-        :good
-      end
-    end
-
-    def status_string
-      if uncoded?
-        "(UNCODED)"
-      elsif unbound?
-        "(UNBOUND)"
-      else
-        "(BOUND)"
-      end
-    end
-
-    def ctrl?
-      @ctrl
-    end
-
-    def meta?
-      @meta
-    end
-
-    def shift?
-      @shift
-    end
-
-    def report
-      if uncoded?
-        report_for_uncoded
-      elsif unbound?
-        report_for_unbound
-      else
-        report_for_bound
-      end
-    end
-
     def report_for_uncoded
       rule = colorize("=" * 55) + "\n"
       out = +""
@@ -280,16 +292,6 @@ module Fatty
       end
     end
 
-    def suggested_snippet(terminal_name)
-      if uncoded?
-        suggested_keydef(terminal_name)
-      elsif unbound?
-        suggested_keybinding
-      else
-        ''
-      end
-    end
-
     def suggested_keydef(terminal_name)
       return "" unless code
 
@@ -301,12 +303,11 @@ module Fatty
 
         ............>8 snip here 8<....................
         #{terminal_name}:
-          map:
-            #{code}:
-              key: key_name
-              shift: <true/false>
-              ctrl: <true/false>
-              meta: <true/false>
+          #{code}:
+            key: key_name
+            shift: <true/false>
+            ctrl: <true/false>
+            meta: <true/false>
         ............>8 snip here 8<....................
       TEXT
     end