Cleanup debug warnings, add comments

Author: Jeremy Wootten

plugins/word-completion/completion-provider.vala

@@ -74,20 +74,14 @@ public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider,
 
         var preceding_word = parser.get_word_immediately_before (text, start_pos);
         if (preceding_word != "") {
-            // warning ("preceding word found %s", preceding_word);
             found = parser.match (preceding_word);
-            // warning ("parser match returned %s", found.to_string ());
             current_text_to_find = found ? preceding_word : "";
-            // warning ("current text to find %s", current_text_to_find);
-        } else {
-            // warning ("No word before");
         }
 
         return found;
     }
 
     public override void populate (Gtk.SourceCompletionContext context) {
-// warning ("populate");
         /*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);
@@ -106,7 +100,6 @@ public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider,
         // If inserting in middle of word then completion overwrites end of word
         var end_pos = end_iter.get_offset ();
         var text = buffer.text;
-        // If word immediately follows then find offset of end and reset end_iter there
         var following_word = parser.get_word_immediately_after (text, end_pos);
         if (following_word != "") {
             buffer.get_iter_at_offset (out end_iter, end_pos + following_word.length);
@@ -140,7 +133,6 @@ public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider,
 
 
     private bool get_proposals (out GLib.List<Gtk.SourceCompletionItem>? props, bool no_minimum) {
-    // warning ("get proposals");
         string to_find = "";
         Gtk.TextBuffer temp_buffer = buffer;
         props = null;
@@ -162,22 +154,17 @@ public class Scratch.Plugins.CompletionProvider : Gtk.SourceCompletionProvider,
             /* Get proposals, if any */
             var completions = parser.get_completions_for_prefix (to_find);
             if (completions.length () > 0) {
-                // warning ("got completions - length %u", completions.length ());
                 foreach (var completion in completions) {
-                    warning ("completion: %s", completion);
                     if (completion.length > 0) {
                         var item = new Gtk.SourceCompletionItem ();
                         var word = to_find + completion;
                         item.label = word;
                         item.text = completion;
-                        // warning ("adding completion");
                         props.append (item);
                     }
                 }
 
                 return true;
-            } else {
-                // warning ("No completions");
             }
         }
 

plugins/word-completion/engine.vala

@@ -21,7 +21,7 @@
 
 public class Euclide.Completion.Parser : GLib.Object {
     private class WordOccurrences {
-        public int occurrences;
+        private int occurrences;
 
         public WordOccurrences () {
             occurrences = 1;
@@ -53,13 +53,17 @@ public class Euclide.Completion.Parser : GLib.Object {
         return uc == null || DELIMITERS.index_of_char (uc) > -1;
     }
 
+    // Custom function required so that the tail_map iterator returns all words that have
+    // the target word as a prefix
     public static int compare_words (string word_a, string word_b) {
+        // Only compare the first n characters
         var scomp = Posix.strncmp (word_a, word_b, word_a.length);
+        // If same prefix then order by word length
         if (scomp == 0 && word_b.length > word_a.length) {
             return -1;
         }
 
-        return scomp;
+        return 1;
     }
 
     private Gee.TreeMap<string, WordOccurrences>? current_tree = null;
@@ -75,7 +79,6 @@ public class Euclide.Completion.Parser : GLib.Object {
         bool pre_existing = true;
 
         if (!text_view_words.has_key (view)) {
-            // text_view_words.@set (view, new Scratch.Plugins.PrefixTree ());
             var new_treemap = new Gee.TreeMap<string, WordOccurrences> (compare_words, null);
             new_treemap.set_data<bool> (COMPLETED, false);
             new_treemap.set_data<Gee.LinkedList<string>> (WORDS_TO_REMOVE, new Gee.LinkedList<string> ());
@@ -101,7 +104,6 @@ public class Euclide.Completion.Parser : GLib.Object {
     }
 
     public void initial_parse_buffer_text (string buffer_text) {
-    warning ("initial parse buffer - length %u", buffer_text.length);
         parsing_cancelled = false;
         clear ();
         if (buffer_text.length > 0) {
@@ -111,7 +113,7 @@ public class Euclide.Completion.Parser : GLib.Object {
             set_initial_parsing_completed (true);
         }
 
-        warning ("initial parsing %s", get_initial_parsing_completed () ? "completed" : "INCOMPLETE");
+        debug ("initial parsing %s", get_initial_parsing_completed () ? "completed" : "INCOMPLETE");
     }
 
     // Returns true if text was completely parsed
@@ -125,7 +127,6 @@ public class Euclide.Completion.Parser : GLib.Object {
         return !parsing_cancelled;
     }
 
-    // Returns whether text was completely parsed
     public bool parse_text_and_remove (string text) {
         if (text.length < MINIMUM_WORD_LENGTH) {
             return false;
@@ -148,8 +149,6 @@ public class Euclide.Completion.Parser : GLib.Object {
         out string word_before,
         out string word_after
     ) {
-
-//        warning ("get words before and after pos %i", offset);
         var pos = offset;
         word_before = "";
         word_after = "";
@@ -162,8 +161,6 @@ public class Euclide.Completion.Parser : GLib.Object {
         if (forward_word_end (text, ref pos, true) && pos >= offset) {
             word_after = text.slice (offset, pos);
         }
-
-//        warning ("got word before %s, word after %s", word_before, word_after);
     }
 
     public string get_word_immediately_before (string text, int end_pos) {
@@ -191,11 +188,9 @@ public class Euclide.Completion.Parser : GLib.Object {
             var start = pos;
             forward_word_end (text, ref pos);
             word = text.slice (start, pos).strip ();
-//            warning ("found %s", word);
             return true;
         }
 
-        // warning ("Next word not found");
         return false;
     }
 
@@ -205,7 +200,6 @@ public class Euclide.Completion.Parser : GLib.Object {
     // Offset is in bytes NOT unichars!
     private bool forward_word_start (string text, ref int offset, bool immediate = false) {
         if (offset >= text.length - MINIMUM_WORD_LENGTH) {
-//            warning ("offset too large");
             return false;
         }
 
@@ -215,25 +209,21 @@ public class Euclide.Completion.Parser : GLib.Object {
 
         // Skip delimiters before word
         do {
-//            warning ("forward word end while IS delimiter - pos %i", offset);
             found = text.get_next_char (ref offset, out uc);
             delimiters++;
         } while (found && is_delimiter (uc));
 
         if (immediate && delimiters > 0) {
-            // warning ("Found preceding delimiters - not immediate");
             return false;
         }
 
         if (!found) {
             // Unable to find next non-delimiter in text - must be end of text
-//            warning (" no more word starts");
             return false;
         }
 
         // Skip back
         text.get_prev_char (ref offset, out uc);
-//        warning ("word start after skip back offset %i", offset);
         return true;
     }
 
@@ -243,7 +233,6 @@ public class Euclide.Completion.Parser : GLib.Object {
     // Offset is in bytes NOT unichars!
     private bool forward_word_end (string text, ref int offset, bool immediate = false) {
         if (offset >= text.length) {
-//            warning ("offset too large");
             return false;
         }
 
@@ -253,7 +242,6 @@ public class Euclide.Completion.Parser : GLib.Object {
 
         // Skip delimiters before word
         do {
-//            warning ("forward word end while IS delimiter - pos %i", offset);
             found = text.get_next_char (ref offset, out uc);
             delimiters++;
         } while (found && is_delimiter (uc));
@@ -264,24 +252,20 @@ public class Euclide.Completion.Parser : GLib.Object {
         }
 
         if (!found) { // Reached end of text without finding target
-//            warning ("No more word ends");
             return false;
         }
 
         // Skip chars in word
         do {
-//            warning ("forward word end while IS char - pos %i", offset);
             found = text.get_next_char (ref offset, out uc);
         } while (found && !is_delimiter (uc));
 
         if (!found) { // Reached end of text without finding target
-//            warning ("End of text is word end - pos %i", offset);
             return true;
         }
 
         // Pointing after first delimiter after word end - back up if not text end
         text.get_prev_char (ref offset, out uc);
-//        warning ("word end after skip back offset %i", offset);
         return true;
     }
 
@@ -291,32 +275,29 @@ public class Euclide.Completion.Parser : GLib.Object {
         unichar? uc = null;
         bool found = false;
         int delimiters = -1;
+
         // Skip delimiters before start point
         do {
-//            warning ("backward word start while IS delimiter - pos %i", offset);
             found = text.get_prev_char (ref offset, out uc);
             delimiters++;
         } while (found && is_delimiter (uc));
 
         if (immediate && delimiters > 0) {
-            // warning ("Found preceding delimiters - not immediate");
             return false;
         }
 
         if (!found) {
             // Unable to find next non-delimiter before
-//            warning (" no more word starts");
             return false;
         }
 
         // Skip chars before in word
         do {
-//            warning ("forward word end while IS char - pos %i", offset);
             found = text.get_prev_char (ref offset, out uc);
         } while (found && !is_delimiter (uc));
 
-        if (!found) { // Reached start of text without finding target - must be word start
-//            warning ("Start of text is word start - pos %i", offset);
+        if (!found) {
+            // Reached start of text without finding target - must be word start
             return true;
         }
 
@@ -335,28 +316,20 @@ public class Euclide.Completion.Parser : GLib.Object {
         parsing_cancelled = false;
     }
 
-    private Gee.SortedMap<string, WordOccurrences> get_submap_for_prefix (string prefix) {
-        return current_tree.tail_map (prefix);
-    }
-
     Gee.SortedMap<string, WordOccurrences> sub_map;
     public bool match (string prefix) requires (current_tree != null) {
-        current_tree.map_iterator ().foreach ((word, occurrences) => {
-            warning ("current tree:  %s (%i)", word, occurrences.occurrences);
-            return Source.CONTINUE;
-        });
-        sub_map = get_submap_for_prefix (prefix);
-
+        // Keep sub map so do not need to reconstruct in get_completions_for_prefix.
+        sub_map = current_tree.tail_map (prefix);
         bool found = false;
         sub_map.map_iterator ().foreach ((word, occurrences) => {
             if (word.has_prefix (prefix)) {
-                // if (occurrences.occurs ()) {
+                if (occurrences.occurs ()) {
                     found = true;
-                    return false; // At least one match
-                // }
+                    return Source.REMOVE; // At least one match
+                }
             }
 
-            return true; // Continue iterations
+            return Source.CONTINUE;
         });
 
         return found;
@@ -367,36 +340,37 @@ public class Euclide.Completion.Parser : GLib.Object {
         var completions = new List<string> ();
         var list = new List<string> ();
         var prefix_length = prefix.length;
-        assert (sub_map != null);
+        // Sub map should always have been constructed in `match ()` function before coming here
+        assert (sub_map != null); 
         var count = 0;
         sub_map.map_iterator ().@foreach ((word, occurrences) => {
-            // warning ("sub_map: %s (%i)", word, occurrences.occurrences);
+            // Submap (tail_map) sometimes contains unexpected word *before* prefix_length
+            // Possibly a bug in Gee? It also contains words that do not start with prefix,
+            // but required words will be contiguous.
             if (word.has_prefix (prefix)) {
-                var completion = word.slice (prefix_length, word.length);
-                // warning ("completion is: %s", completion);
                 if (occurrences.occurs ()) {
+                    var completion = word.slice (prefix_length, word.length);
                     completions.prepend (completion);
                 }
 
                 count++;
-                return true;
+                return Source.CONTINUE;
             }
 
             return count == 0; // Ignore words before prefix
         });
 
+        sub_map = null;
         return (owned)completions;
     }
 
     // Only call if known that @word is a single word
     public void add_word (string word_to_add) requires (current_tree != null) {
         if (is_valid_word (word_to_add)) {
             if (current_tree.has_key (word_to_add)) {
-                // warning ("found word %s", word_to_add);
                 var word_occurrences = current_tree.@get (word_to_add);
                 word_occurrences.increment ();
             } else {
-                warning ("inserting new word %s", word_to_add);
                 current_tree.@set (word_to_add, new WordOccurrences ());
             }
         }
@@ -412,10 +386,8 @@ public class Euclide.Completion.Parser : GLib.Object {
                 var word_occurrences = current_tree.@get (word_to_remove);
                 word_occurrences.decrement ();
                 if (!word_occurrences.occurs ()) {
-                    warning ("%s does not occur - schedule remove", word_to_remove);
                     var words_to_remove = get_words_to_remove ();
                         words_to_remove.add (word_to_remove);
-                        warning ("words to remove length %i", words_to_remove.size);
                         schedule_reaping ();
                 }
             }
@@ -428,7 +400,6 @@ public class Euclide.Completion.Parser : GLib.Object {
 
     private bool reaping_cancelled = false;
     private void cancel_reaping () {
-        warning ("cancel reaping");
         if (reaper_timeout_id > 0) {
             Source.remove (reaper_timeout_id);
         }
@@ -448,16 +419,13 @@ public class Euclide.Completion.Parser : GLib.Object {
                 } else {
                     reaper_timeout_id = 0;
                     var words_to_remove = get_words_to_remove ();
-                    warning ("reaping %i words", words_to_remove.size);
                     words_to_remove.foreach ((word) => {
                         if (reaping_cancelled) {
-                            warning ("reaping cancelled!");
                             return false;
                         }
 
                         var occurrences = current_tree.@get (word);
                         if (occurrences != null && !occurrences.occurs ()) {
-                            warning ("Reaping %s", word);
                             current_tree.unset (word);
                         }