Dynamically update word completions

plugins/word-completion/completion-provider.vala

@@ -1,4 +1,5 @@
 /*
+ * Copyright 2024 elementary, Inc. <https://elementary.io>
  * Copyright (c) 2013 Mario Guerriero <[email protected]>
  *
  * This is a free software; you can redistribute it and/or
@@ -18,94 +19,109 @@
  *
  */
 
-public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider, Object {
-    public string name;
-    public int priority;
+public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider, GLib.Object {
+    private const int MAX_COMPLETIONS = 10;
+    public string name { get; construct; }
+    public int priority { get; construct; }
+    public int interactive_delay { get; construct; }
+    public Gtk.SourceCompletionActivation activation { get; construct; }
 
     public const string COMPLETION_END_MARK_NAME = "ScratchWordCompletionEnd";
     public const string COMPLETION_START_MARK_NAME = "ScratchWordCompletionStart";
 
-    private Gtk.TextView? view;
-    private Gtk.TextBuffer? buffer;
-    private Euclide.Completion.Parser parser;
+    public Gtk.TextView? view { get; construct; }
+    public Euclide.Completion.Parser parser { get; construct; }
+
+    private unowned Gtk.TextBuffer buffer {
+        get {
+            return view.buffer;
+        }
+    }
+
     private Gtk.TextMark completion_end_mark;
     private Gtk.TextMark completion_start_mark;
+    private string current_text_to_find = "";
 
     public signal void can_propose (bool b);
 
-    public CompletionProvider (Scratch.Plugins.Completion completion) {
-        this.view = completion.current_view as Gtk.TextView;
-        this.buffer = completion.current_view.buffer;
-        this.parser = completion.parser;
+    public CompletionProvider (
+        Euclide.Completion.Parser _parser,
+        Scratch.Services.Document _doc
+        ) {
+
+        Object (
+            parser: _parser,
+            view: _doc.source_view,
+            name: _("%s - Word Completion").printf (_doc.get_basename ())
+        );
+    }
+
+    construct {
+        interactive_delay = (int) Completion.INTERACTIVE_DELAY;
+        activation = INTERACTIVE | USER_REQUESTED;
         Gtk.TextIter iter;
-        buffer.get_iter_at_offset (out iter, 0);
+        view.buffer.get_iter_at_offset (out iter, 0);
         completion_end_mark = buffer.create_mark (COMPLETION_END_MARK_NAME, iter, false);
         completion_start_mark = buffer.create_mark (COMPLETION_START_MARK_NAME, iter, false);
     }
 
-    public string get_name () {
-        return this.name;
-    }
+    public override bool match (Gtk.SourceCompletionContext context) {
+        var iter = context.iter;
+        var start_iter = iter;
+        var end_iter = iter;
+        bool found = false;
 
-    public int get_priority () {
-        return this.priority;
-    }
-
-    public bool match (Gtk.SourceCompletionContext context) {
-        Gtk.TextIter start, end;
-        buffer.get_iter_at_offset (out end, buffer.cursor_position);
-        start = end.copy ();
-        Euclide.Completion.Parser.back_to_word_start (ref start);
-        string text = buffer.get_text (start, end, true);
+        var preceding_word = parser.get_word_immediately_before (iter);
+        if (preceding_word != "") {
+            found = parser.match (preceding_word);
+            current_text_to_find = found ? preceding_word : "";
+        }
 
-        return parser.match (text);
+        return found;
     }
 
-    public void populate (Gtk.SourceCompletionContext context) {
+    public override void populate (Gtk.SourceCompletionContext context) {
         /*Store current insertion point for use in activate_proposal */
         GLib.List<Gtk.SourceCompletionItem>? file_props;
         bool no_minimum = (context.get_activation () == Gtk.SourceCompletionActivation.USER_REQUESTED);
         get_proposals (out file_props, no_minimum);
         context.add_proposals (this, file_props, true);
     }
 
-    public bool activate_proposal (Gtk.SourceCompletionProposal proposal, Gtk.TextIter iter) {
+    public override bool activate_proposal (Gtk.SourceCompletionProposal proposal, Gtk.TextIter iter) {
         Gtk.TextIter start;
-        Gtk.TextIter end;
+        Gtk.TextIter end_iter;
         Gtk.TextMark mark;
 
         mark = buffer.get_mark (COMPLETION_END_MARK_NAME);
-        buffer.get_iter_at_mark (out end, mark);
+        buffer.get_iter_at_mark (out end_iter, mark);
+        var end_pos = end_iter.get_offset ();
+        // If inserting in middle of word then completion overwrites end of word
+        var following_word = parser.get_word_immediately_after (end_iter);
+        if (following_word != "") {
+            buffer.get_iter_at_offset (out end_iter, end_pos + following_word.length);
+        }
 
         mark = buffer.get_mark (COMPLETION_START_MARK_NAME);
         buffer.get_iter_at_mark (out start, mark);
 
-        buffer.@delete (ref start, ref end);
+        buffer.@delete (ref start, ref end_iter);
         buffer.insert (ref start, proposal.get_text (), proposal.get_text ().length);
         return true;
     }
 
-    public Gtk.SourceCompletionActivation get_activation () {
-        return Gtk.SourceCompletionActivation.INTERACTIVE |
-               Gtk.SourceCompletionActivation.USER_REQUESTED;
-    }
-
-    public int get_interactive_delay () {
-        return 0;
-    }
-
-    public bool get_start_iter (Gtk.SourceCompletionContext context,
+    public override bool get_start_iter (Gtk.SourceCompletionContext context,
                                 Gtk.SourceCompletionProposal proposal,
                                 out Gtk.TextIter iter) {
-        var mark = buffer.get_insert ();
-        Gtk.TextIter cursor_iter;
-        buffer.get_iter_at_mark (out cursor_iter, mark);
 
-        iter = cursor_iter;
-        Euclide.Completion.Parser.back_to_word_start (ref iter);
+        var word_start = buffer.cursor_position;
+        buffer.get_iter_at_offset (out iter, word_start);
         return true;
     }
 
+    public override string get_name () {
+        return name;
+    }
 
     private bool get_proposals (out GLib.List<Gtk.SourceCompletionItem>? props, bool no_minimum) {
         string to_find = "";
@@ -114,36 +130,38 @@ public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider,
 
         Gtk.TextIter start, end;
         buffer.get_selection_bounds (out start, out end);
-
         to_find = temp_buffer.get_text (start, end, true);
 
         if (to_find.length == 0) {
-            temp_buffer.get_iter_at_offset (out end, buffer.cursor_position);
-
-            start = end;
-            Euclide.Completion.Parser.back_to_word_start (ref start);
-
-            to_find = buffer.get_text (start, end, false);
+            to_find = current_text_to_find;
         }
 
         buffer.move_mark_by_name (COMPLETION_END_MARK_NAME, end);
         buffer.move_mark_by_name (COMPLETION_START_MARK_NAME, start);
 
         /* There is no minimum length of word to find if the user requested a completion */
-        if (no_minimum || to_find.length >= Euclide.Completion.Parser.MINIMUM_WORD_LENGTH) {
+        if (no_minimum || to_find.length >= Euclide.Completion.Parser.MINIMUM_PREFIX_LENGTH) {
             /* Get proposals, if any */
-            List<string> prop_word_list;
-            if (parser.get_for_word (to_find, out prop_word_list)) {
-                foreach (var word in prop_word_list) {
-                    var item = new Gtk.SourceCompletionItem ();
-                    item.label = word;
-                    item.text = word;
-                    props.append (item);
+            var completions = parser.get_current_completions (to_find);
+            if (completions.length () > 0) {
+                var index = 0;
+                foreach (var completion in completions) {
+                    if (completion.length > 0) {
+                        var item = new Gtk.SourceCompletionItem ();
+                        var word = to_find + completion;
+                        item.label = word;
+                        item.text = completion;
+                        props.append (item);
+                        if (++index > MAX_COMPLETIONS) {
+                            break;
+                        }
+                    }
                 }
 
                 return true;
             }
         }
+
         return false;
     }
 }