Through the view.show_popup to achieve the function of goto-definition. Added record and macro goto-definition function.

Author: lintingbin

Default.sublime-mousemap

@@ -3,5 +3,9 @@
     //     "modifiers": ["ctrl"], "button": "button1", 
     //     "command": "goto",
     //     "press_command": "drag_select"
+    // },
+    // {
+    //     "modifiers": ["ctrl"], "button": "button2", 
+    //     "command": "jump_back",
     // }
 ]

erl_autocompletion.py

@@ -3,9 +3,11 @@
 import sublime_plugin, sublime, re, os, sys, shutil
 
 cache = {}
+go_to = None
 
 def plugin_loaded():
     global cache
+    global go_to
 
     cache_dir = os.path.join(sublime.cache_path(), GLOBAL_SET['package_name'])
     cache['libs'] = DataCache([get_erl_lib_dir()], 'libs', cache_dir)
@@ -16,6 +18,8 @@ def plugin_loaded():
     cache['project'] = DataCache(project_folder, 'project', cache_dir)
     cache['project'].build_data_async()
 
+    go_to = GoTo()
+
 def plugin_unloaded():
     from package_control import events
 
@@ -29,16 +33,7 @@ def plugin_unloaded():
     plugin_loaded()
     unload_handler = plugin_unloaded
 
-class SaveFileRebuildListener(sublime_plugin.EventListener):
-    def on_post_save(self, view):
-        caret = view.sel()[0].a
-
-        if not ('source.erlang' in view.scope_name(caret)): 
-            return
-
-        cache['project'].build_data_async()
-
-class CompletionsListener(sublime_plugin.EventListener):
+class ErlListener(sublime_plugin.EventListener):
     def on_query_completions(self, view, prefix, locations):
         if cache['libs'].libs == {}: 
             return
@@ -62,103 +57,24 @@ def on_query_completions(self, view, prefix, locations):
             if module_name in cache['project'].libs:
                 return (cache['project'].libs[module_name], flag)
 
-class GotoCommand(sublime_plugin.TextCommand, DataCache):
-    def __init__(self, view):
-        sublime_plugin.TextCommand.__init__(self, view)
-        DataCache.__init__(self)
-        self.window = sublime.active_window()
-
-    def run(self, edit):
-        line_str = self.__get_line_str(self.view)
-
-        math = self.re_dict['take_mf'].search(line_str)
-        if math is not None and (len(math.groups()) == 2):
-            module_name = math.group(1)
-            fun_name = math.group(2)
-
-            key = (module_name, fun_name)
-            if key in cache['libs'].fun_postion:
-                self.__window_quick_panel_open_window(cache['libs'].fun_postion[key])
-            elif key in cache['project'].fun_postion:
-                self.__window_quick_panel_open_window(cache['project'].fun_postion[key])
-
-            return
+    def on_text_command(self, view, command_name, args):
+        if command_name == 'goto' and 'event' in args:
+            event = args['event']
+            point = view.window_to_text((event['x'], event['y']))
 
-        math = self.re_dict['take_fun'].search(line_str)
-        if math is not None and (len(math.groups()) == 1):
-            fun_name = math.group(1)
-
-            filepath = self.view.file_name()
-            libs_key = ('erlang', fun_name)
-            cur_module = self.get_module_from_path(filepath)
-            project_key = (cur_module, fun_name)
-            if libs_key in cache['libs'].fun_postion:
-                self.__window_quick_panel_open_window(cache['libs'].fun_postion[libs_key])
-            else:
-                row_id = 1
-                cur_view_postion = {}
-                all_cur_view_fun = []
-                module = self.get_module_from_path(filepath)
-                code = self.view.substr(sublime.Region(0, self.view.size()))
-                for line in code.split('\n'):
-                    funhead = self.re_dict['funline'].search(line)
-                    if funhead is not None: 
-                        fun_name = funhead.group(1)
-                        param_str = funhead.group(2)
-                        param_list = self.format_param(param_str)
-                        key = (module, fun_name)
-                        param_len = len(param_list)
-                        format_fun_name = '{0}/{1}'.format(fun_name, param_len)
-                        
-                        if (key, param_len) not in all_cur_view_fun:
-                            if key not in cur_view_postion:
-                                cur_view_postion[key] = []
-                            cur_view_postion[key].append((format_fun_name, filepath, row_id))
-                            all_cur_view_fun.append((key, param_len))
-                    row_id += 1
-
-                self.__window_quick_panel_open_window(cur_view_postion[project_key])
-
-            return
-
-    def __get_line_str(self, view):
-        location = view.sel()[0].begin()
-        line_region = view.line(location)
-        line_str = view.substr(line_region)
+            if not view.match_selector(point, "source.erlang"): 
+                return
 
-        return line_str
+            go_to.run(point, view, cache)
 
-    def __window_quick_panel_open_window(self, options):
-        self.point = self.view.sel()[0]
-        self.options = options
+    def on_post_save(self, view):
+        caret = view.sel()[0].a
 
-        if len(options) == 1:
-            (_fun_name, path, row) = options[0]
-            self.window.open_file('{}:{}:0'.format(path, row), sublime.ENCODED_POSITION)
+        if not ('source.erlang' in view.scope_name(caret)): 
             return
 
-        self.window.show_quick_panel(
-            [self.__show_option(o) for o in options],
-            self._jump_to_in_window,
-            on_highlight=partial(self._jump_to_in_window, transient=sublime.TRANSIENT))
-
-    def __show_option(self, options):
-        return '{1}:{0} line: {2}'.format(*options)
-
-    def _jump_to_in_window(self, index, line_number=None, param_cnt=None, transient=0):
-
-        try:
-            if self.view.sel()[0] != self.point:
-                self.view.sel().clear()
-                self.view.sel().add(self.point)
-        except AttributeError:
-            pass
-
-        if isinstance(index, int):
-            if index == -1:  
-                self.window.focus_view(self.view)
-                self.view.show(self.point)
-                return
+        cache['project'].build_data_async()
 
-        (fun_name, filename, line_number) = self.options[index]
-        self.window.open_file('{0}:{1}'.format(filename, line_number or 0), sublime.ENCODED_POSITION|transient)
+class GotoCommand(sublime_plugin.TextCommand):
+    def run(self, edit):
+        return

util/__init__.py

@@ -1,2 +1,3 @@
 from .data_cache import DataCache
-from .settings import get_erl_lib_dir, get_settings_param, GLOBAL_SET
+from .settings import get_erl_lib_dir, get_settings_param, GLOBAL_SET
+from .go_to import GoTo

util/data_cache.py

@@ -5,7 +5,7 @@ class DataCache:
     def __init__(self, dir = '', data_type = '', cache_dir = ''):
         self.dir = dir
         self.libs = {}
-        self.fun_postion = {}
+        self.fun_position = {}
         self.modules = []
         self.data_type = data_type
         self.cache_dir = cache_dir
@@ -42,9 +42,9 @@ def build_module_dict(self, filepath):
                         format_fun_name = '{0}/{1}'.format(fun_name, param_len)
                         self.libs[module].append(('{0}\tfunction'.format(format_fun_name), completion))
 
-                        if (module, fun_name) not in self.fun_postion:
-                            self.fun_postion[(module, fun_name)] = []
-                        self.fun_postion[(module, fun_name)].append((format_fun_name, filepath, row_id))
+                        if (module, fun_name) not in self.fun_position:
+                            self.fun_position[(module, fun_name)] = []
+                        self.fun_position[(module, fun_name)].append((format_fun_name, filepath, row_id))
                 row_id += 1
             self.modules.append({'trigger' : '{0}\tmodule'.format(module), 'contents' : module})
 
@@ -102,7 +102,7 @@ def build_data(self):
                     all_filepath.append(os.path.join(root, file))
 
         if all_filepath == []:
-            (self.libs, self.fun_postion) = self.__load_data('completion')
+            (self.libs, self.fun_position) = self.__load_data('completion')
         else:
             cache_info = self.__load_data('cache_info')
             all_filepath_md5 = hashlib.md5(json.dumps(all_filepath).encode('UTF-8')).hexdigest()
@@ -116,10 +116,10 @@ def build_data(self):
                         self.modules.append({'trigger' : trigger, 'contents' : content})
 
                 self.__save_data('cache_info', new_cache_info)
-                self.__save_data('completion', (self.libs, self.fun_postion))
+                self.__save_data('completion', (self.libs, self.fun_position))
                 self.__dump_json('erlang.sublime-completions', {'scope': 'source.erlang', 'completions': self.modules})
             else:
-                (self.libs, self.fun_postion) = self.__load_data('completion')
+                (self.libs, self.fun_position) = self.__load_data('completion')
 
     def build_data_async(self):
         this = self

util/go_to.py

@@ -0,0 +1,133 @@
+from .data_cache import DataCache
+import sublime, re, os
+
+class GoTo(DataCache):
+    def __init__(self):
+        DataCache.__init__(self)
+        self.max_col = 400
+
+    def run(self, point, view, cache):
+        line_region = view.line(point)
+        line_str = view.substr(line_region)
+        word_region = view.word(point)
+        word = view.substr(word_region)
+        filepath = view.file_name()
+
+        maths = self.re_dict['take_mf'].findall(line_str)
+        for math in maths:
+            if word in math:
+                if self.open_function_popup(view, point, math[0], math[1], cache['libs'].fun_position):
+                    return
+                if self.open_function_popup(view, point, math[0], math[1], cache['project'].fun_position):
+                    return
+
+        maths = self.re_dict['take_fun'].findall(line_str)
+        for math in maths:
+            if word == math:
+                module = self.get_module_from_path(filepath)
+                if self.open_function_popup(view, point, 'erlang', math, cache['libs'].fun_position):
+                    return
+                if self.open_function_popup(view, point, module, math, self.build_module_position(view, module, filepath)):
+                    return
+
+        maths = self.re_dict['take_record'].findall(line_str)
+        for math in maths:
+            if word == math:
+                re_define = re.compile(r'(-\s*record\s*\([\s\n\r]*' + word + r'[\s\n\r]*,[\s\n\r]*{[^-]*}[\s\n\r]*\)\.)', re.MULTILINE|re.DOTALL)
+                if self.open_hrl_popup(view, re_define, filepath, point):
+                    return
+
+        maths = self.re_dict['take_define'].findall(line_str)
+        for math in maths:
+            if word == math:
+                re_define = re.compile(r'(-\s*define\s*\([\s\n\r]*' + word + r'[\s\n\r]*,[\s\n\r]*[^-]*\)\.)', re.MULTILINE|re.DOTALL)
+                if self.open_hrl_popup(view, re_define, filepath, point):
+                    return
+
+    def open_function_popup(self, view, point, module, function, all_function):
+        key = (module, function)
+        if key in all_function:
+            col = 0
+            row = 1
+            html_content = '<div>Definitions:</div>'
+            for (name, path, row) in all_function[key]:
+                add_str = '<div>{0}:{1} <a href="{2}:{3}:0">{2}:{3}</a></div>'.format(module, name, path, row)
+                html_content += add_str
+                col = max(len(add_str), col)
+                row += 1
+
+            view.show_popup(html_content, max_height = self.get_height(row), max_width = self.get_width(col), 
+                flags = sublime.HIDE_ON_MOUSE_MOVE_AWAY, location = point, 
+                on_navigate = self.on_navigate_cb)
+            return True
+        return False
+
+    def build_module_position(self, view, module, filepath):
+        row_id = 1
+        cur_view_position = {}
+        all_cur_view_fun = []
+        code = self.get_view_code(view)
+        for line in code.split('\n'):
+            funhead = self.re_dict['funline'].search(line)
+            if funhead is not None: 
+                fun_name = funhead.group(1)
+                param_str = funhead.group(2)
+                param_list = self.format_param(param_str)
+                key = (module, fun_name)
+                param_len = len(param_list)
+                format_fun_name = '{0}/{1}'.format(fun_name, param_len)
+                
+                if (key, param_len) not in all_cur_view_fun:
+                    if key not in cur_view_position:
+                        cur_view_position[key] = []
+                    cur_view_position[key].append((format_fun_name, filepath, row_id))
+                    all_cur_view_fun.append((key, param_len))
+            row_id += 1
+        return cur_view_position
+
+    def open_hrl_popup(self, view, re_define, filepath, point):
+        with open(filepath, encoding = 'UTF-8', errors='ignore') as fd:
+            content = fd.read()
+            code = re.sub(self.re_dict['comment'], '\n', content)
+
+        re_newline = re.compile(r'\n')
+        for m in re_define.finditer(code):
+            start_line = len(re_newline.findall(code, 0, m.start(1))) + 1
+            html_content = '<div>Definitions:</div>'
+            record_define = '<div>{0}</div>'.format(m.group(1))
+            reocrd_address = '<div><a href="{0}:{1}:0">{0}:{1}</a></div>'.format(filepath, start_line)
+            record_define_len = len(record_define)
+            if record_define_len > self.max_col:
+                html_content += reocrd_address
+                col = len(reocrd_address)
+            else:
+                html_content += record_define + reocrd_address
+                col = max(record_define_len, len(reocrd_address))
+
+            view.show_popup(html_content, max_height = self.get_height(3), max_width = self.get_width(col), 
+                flags = sublime.HIDE_ON_MOUSE_MOVE_AWAY, location = point, 
+                on_navigate = self.on_navigate_cb)
+            return True
+        
+        (directory, filename) = os.path.split(filepath)
+        for m in self.re_dict['take_include'].finditer(code):
+            hrl_name = m.group(1)
+            hrl_path = os.path.normpath(os.path.join(directory, hrl_name))
+            if self.open_hrl_popup(view, re_define, hrl_path, point):
+                return True
+                
+        return False
+
+    def on_navigate_cb(self, address):
+        sublime.active_window().open_file(address, sublime.ENCODED_POSITION)
+
+    def get_view_code(self, view):
+        view_region = sublime.Region(0, view.size())
+        code = view.substr(view_region)
+        return code
+
+    def get_height(self, row):
+        return row * 240
+
+    def get_width(self, col):
+        return col * 20

util/settings.py

@@ -29,7 +29,10 @@ def get_erl_lib_dir():
         'special_param': re.compile(r'(?:\{.*\})|(?:<<.*>>)|(?:\[.*\])'),
         '=' : re.compile(r'\s*=\s*\w+'),
         'take_mf' : re.compile(r'(\w+)\s*:\s*(\w+)\s*\('),
-        'take_fun' : re.compile(r'(\w+)\s*\(')
+        'take_fun' : re.compile(r'(\w+)\s*\('),
+        'take_record' : re.compile(r'\#\s*(\w+)\s*[\{|.]'),
+        'take_define' : re.compile(r'\?\s*(\w+)'),
+        'take_include' : re.compile(r'-include\("([^\)]*)"\)')
     },
     'package_name' : 'Erl-AutoCompletion'
 }