Moved completers to new dir; improved completers and added word completion

plugins/completers/words_completer/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Pligin Module
+"""

plugins/completers/words_completer/__main__.py

@@ -0,0 +1,3 @@
+"""
+    Pligin Package
+"""

plugins/completers/words_completer/alt_provider.py

@@ -0,0 +1,53 @@
+# Python imports
+import re
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GObject
+from gi.repository import Gtk
+from gi.repository import GtkSource
+
+# Application imports
+from .provider_response_cache import ProviderResponseCache
+
+
+
+class Provider(GtkSource.CompletionWords):
+    """
+        This is a Words Completion Provider.
+        # NOTE: used information from here --> https://warroom.rsmus.com/do-that-auto-complete/
+    """
+    __gtype_name__ = 'WordsCompletionProvider'
+
+    def __init__(self):
+        super(Provider, self).__init__()
+
+        self.response_cache: ProviderResponseCache = ProviderResponseCache()
+
+
+    def do_get_name(self):
+        return 'Words Completion'
+
+    def do_match(self, context):
+        word = self.response_cache.get_word(context)
+        if not word or len(word) < 2: return False
+        return True
+
+    def do_get_priority(self):
+        return 0
+
+    def do_activate_proposal(self, proposal, iter_):
+        buffer = iter_.get_buffer()
+        # Note: Flag mostly intended for SourceViewsMultiInsertState
+        #       to insure marker processes inserted text correctly.
+        buffer.is_processing_completion = True
+        return False
+
+    def do_get_activation(self):
+        """ The context for when a provider will show results """
+        # return GtkSource.CompletionActivation.NONE
+        # return GtkSource.CompletionActivation.USER_REQUESTED
+        return GtkSource.CompletionActivation.INTERACTIVE

plugins/completers/words_completer/manifest.json

@@ -0,0 +1,7 @@
+{
+    "name": "Words Completer",
+    "author": "ITDominator",
+    "version": "0.0.1",
+    "support": "",
+    "requests": {}
+}

plugins/completers/words_completer/plugin.py

@@ -0,0 +1,40 @@
+# Python imports
+
+# Lib imports
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+
+# Application imports
+from libs.dto.base_event import BaseEvent
+from libs.event_factory import Event_Factory
+
+from plugins.plugin_types import PluginCode
+
+from .provider import Provider
+
+
+
+class Plugin(PluginCode):
+    def __init__(self):
+        super(Plugin, self).__init__()
+
+        self.provider: Provider = None
+
+
+    def _controller_message(self, event: BaseEvent):
+        ...
+
+    def load(self):
+        self.provider = Provider()
+
+        event = Event_Factory.create_event(
+            "register_provider",
+            provider_name = "Words Completer",
+            provider      = self.provider,
+            language_ids  = []
+        )
+        self.message_to("completion", event)
+
+    def run(self):
+        ...

plugins/completers/words_completer/provider.py

@@ -0,0 +1,71 @@
+# Python imports
+import re
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GObject
+from gi.repository import GtkSource
+
+# Application imports
+from .provider_response_cache import ProviderResponseCache
+
+
+
+class Provider(GObject.GObject, GtkSource.CompletionProvider):
+    """
+        This is a Words Completion Provider.
+        # NOTE: used information from here --> https://warroom.rsmus.com/do-that-auto-complete/
+    """
+    # __gtype_name__ = 'WordsCompletionProvider'
+
+    def __init__(self):
+        super(Provider, self).__init__()
+
+        self.response_cache: ProviderResponseCache = ProviderResponseCache()
+
+
+    def do_get_name(self):
+        return 'Words Completion'
+
+    def do_match(self, context):
+        word = self.response_cache.get_word(context)
+        if not word or len(word) < 2: return False
+        return True
+
+    def do_get_priority(self):
+        return 0
+
+    def do_activate_proposal(self, proposal, iter_):
+        buffer = iter_.get_buffer()
+        # Note: Flag mostly intended for SourceViewsMultiInsertState
+        #       to insure marker processes inserted text correctly.
+        buffer.is_processing_completion = True
+        return False
+
+    def do_get_activation(self):
+        """ The context for when a provider will show results """
+        # return GtkSource.CompletionActivation.NONE
+        # return GtkSource.CompletionActivation.USER_REQUESTED
+        return GtkSource.CompletionActivation.INTERACTIVE
+
+    def do_populate(self, context):
+        word    = self.response_cache.get_word(context)
+        results = self.response_cache.filter_with_context(context)
+        # results = self.response_cache.filter(word)
+
+        # if not results:
+        #     results = self.response_cache.filter_with_context(context)
+
+        proposals = []
+        for entry in results:
+            proposals.append(
+                self.response_cache.create_completion_item(
+                    entry["label"],
+                    entry["text"],
+                    entry["info"]
+                )
+            )
+
+        context.add_proposals(self, proposals, True)

plugins/completers/words_completer/provider_response_cache.py

@@ -0,0 +1,131 @@
+# Python imports
+from os import path
+
+# Lib imports
+import gi
+gi.require_version('GtkSource', '4')
+
+from gi.repository import GLib
+from gi.repository import GtkSource
+
+# Application imports
+from libs.event_factory import Code_Event_Types
+
+from core.widgets.code.completion_providers.provider_response_cache_base import ProviderResponseCacheBase
+
+
+
+class ProviderResponseCache(ProviderResponseCacheBase):
+    def __init__(self):
+        super(ProviderResponseCache, self).__init__()
+
+        self.matchers: dict = {}
+
+
+    def process_file_load(self, event: Code_Event_Types.AddedNewFileEvent):
+        self.load_as_new_set(event.file.buffer)
+
+    def process_file_close(self, event: Code_Event_Types.RemovedFileEvent):
+        self.matchers[event.file.buffer] = []
+        del self.matchers[event.file.buffer]
+
+    def process_file_save(self, event: Code_Event_Types.SavedFileEvent):
+        ...
+
+    def process_file_change(self, event: Code_Event_Types.TextChangedEvent):
+        buffer = event.file.buffer
+        # if self.get_if_in_matched_word_set(buffer): return
+        self.load_as_new_set(buffer)
+
+
+    def filter(self, word: str) -> list[dict]:
+        response: list[dict] = []
+
+        for entry in self.matchers:
+            if not word in entry: continue
+            data = self.matchers[entry]
+            response.append(data)
+
+        return response
+
+    def filter_with_context(self, context: GtkSource.CompletionContext) -> list[dict]:
+        buffer = self.get_iter_correctly(context).get_buffer()
+        word   = self.get_word(context).rstrip()
+
+        response: list[dict] = []
+        for entry in self.matchers[buffer]:
+            if not entry.rstrip().startswith(word): continue
+
+            data = {
+                "label": entry,
+                "text": entry,
+                "info": ""
+            }
+
+            response.append(data)
+
+        return response
+
+
+    def load_as_new_set(self, buffer):
+        start_itr = buffer.get_start_iter()
+        end_itr   = buffer.get_end_iter()
+        data      = buffer.get_text(start_itr, end_itr, False)
+
+        if not data:
+            self.matchers[buffer] = set()
+            return
+
+        self.matchers[buffer] = self.get_all_words(data)
+
+    def get_if_in_matched_word_set(self, buffer):
+        was_found = False
+
+        if not buffer in self.matchers: return was_found
+
+        insert_itr = buffer.get_iter_at_mark( buffer.get_insert() )
+        end_itr    = insert_itr.copy()
+        start_itr  = end_itr.copy()
+
+        if not start_itr.starts_word():
+            start_itr.backward_word_start()
+
+        if not end_itr.ends_word():
+            end_itr.forward_word_end()
+
+        word      = buffer.get_text(start_itr, end_itr, False)
+        for _word in self.matchers[buffer]:
+            if not _word.startswith(word): continue
+            was_found = True
+
+        if was_found: return was_found
+
+        self.matchers[buffer].add(word)
+
+        return was_found
+
+
+    def get_all_words(self, data: str):
+        words = set()
+
+        def is_word_char(c):
+            return c.isalnum() or c == '_'
+
+        size = len(data)
+        i = 0
+        
+        while i < size:
+            # Skip non-word characters
+            while i < size and not is_word_char(data[i]):
+                i += 1
+
+            start = i
+            # Consume word characters
+            while i < size and is_word_char(data[i]):
+                i += 1
+
+            word = data[start:i]
+            if not word: continue
+            words.add(word)
+
+        return words