def on_query_completions(self, view, prefix, locations):
"""Fired directly from Sublime Text 3 events systems
"""
if not is_code(view, lang='go'):
return
if not go.ANAGONDA_PRESENT:
if go.AVAILABLE:
go.init()
else:
return
if self.ready_from_defer is True:
completion_flags = 0
if get_settings(view, 'suppress_word_completions', False):
completion_flags = sublime.INHIBIT_WORD_COMPLETIONS
if get_settings(view, 'suppress_explicit_completions', False):
completion_flags |= sublime.INHIBIT_EXPLICIT_COMPLETIONS
cpl = self.completions
self.completions = []
self.ready_from_defer = False
return (cpl, completion_flags)
code = view.substr(sublime.Region(0, view.size()))
row, col = view.rowcol(locations[0])
data = {
'vid':
view.id(),
'path':
view.file_name(),
'code':
code,
'offset':
view.text_point(row, col),
'add_params':
get_settings(view, 'anaconda_go_add_completion_params', True),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method':
'autocomplete',
'handler':
'anaGonda'
}
Worker.execute(
Callback(on_success=self._complete,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
def on_query_completions(self, view, prefix, locations):
"""Fired directly from Sublime Text 3 events systems
"""
if not is_code(view, lang='go'):
return
if not go.ANAGONDA_PRESENT:
if go.AVAILABLE:
go.init()
else:
return
if self.ready_from_defer is True:
completion_flags = 0
if get_settings(view, 'suppress_word_completions', False):
completion_flags = sublime.INHIBIT_WORD_COMPLETIONS
if get_settings(view, 'suppress_explicit_completions', False):
completion_flags |= sublime.INHIBIT_EXPLICIT_COMPLETIONS
cpl = self.completions
self.completions = []
self.ready_from_defer = False
return (cpl, completion_flags)
code = view.substr(sublime.Region(0, view.size()))
row, col = view.rowcol(locations[0])
data = {
'vid': view.id(),
'path': view.file_name(),
'code': code,
'offset': view.text_point(row, col),
'add_params': get_settings(
view, 'anaconda_go_add_completion_params', True),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'autocomplete',
'handler': 'anaGonda'
}
Worker.execute(
Callback(
on_success=self._complete,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
def run(self, operation='analyze') -> None:
self.operation = operation
try:
view = self.window.active_view()
self.view = view
scope = get_settings(view, 'anaconda_go_guru_scope')
data = {
'vid': self.view.id(),
'scope': scope if scope is not None else get_scope(view, go.GOPATH), # noqa
'code': view.substr(sublime.Region(0, view.size())),
'offset': view.text_point(*view.rowcol(view.sel()[0].begin())),
'path': view.file_name(),
'buf': self.modified_buffer(view),
'mode': self.operation,
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'analyze_symbol',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', '')))
print(err)
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
data = {
'vid': view.id(),
'file_path': view.file_name(),
'parse_comments': get_settings(
view, 'anaconda_go_motion_parse_comments', False
),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': self.method,
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=ExplorerPanel(view).run,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', ' ')))
print(err)
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
data = {
'vid':
view.id(),
'file_path':
view.file_name(),
'offset':
view.sel()[0].begin(),
'parse_comments':
get_settings(view, 'anaconda_go_motion_parse_comments', False),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method':
'enclosing',
'handler':
'anaGonda'
}
Worker().execute(
Callback(on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: enclosing function error')
print(err)
def run(self, operation='analyze') -> None:
self.operation = operation
try:
view = self.window.active_view()
self.view = view
scope = get_settings(view, 'anaconda_go_guru_scope')
data = {
'vid': self.view.id(),
'scope': scope if scope is not None else get_scope(
view, go.GOPATH), # noqa
'code': view.substr(sublime.Region(0, view.size())),
'offset': view.text_point(*view.rowcol(view.sel()[0].begin())),
'path': view.file_name(),
'buf': self.modified_buffer(view),
'mode': self.operation,
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'analyze_symbol',
'handler': 'anaGonda'
}
Worker().execute(
Callback(on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', '')))
print(err)
def slow_linters(view=None, hook=None):
"""Run slow gometalinter linters
"""
if view is None:
view = active_view()
if not get_settings(view, 'anaconda_go_linting', True):
return
if view.file_name() in anaconda_sublime.ANACONDA['DISABLED']:
anaconda_sublime.erase_lint_marks(view)
return
settings = _get_settings(view)
data = {
'vid': view.id(),
'code': view.substr(st3_sublime.Region(0, view.size())),
'settings': settings,
'filepath': view.file_name(),
'method': 'slow_lint',
'handler': 'anaGonda',
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
}
}
callback = partial(anaconda_sublime.parse_results, **dict(code='go'))
if hook is None:
Worker().execute(Callback(on_success=callback), **data)
else:
Worker().execute(Callback(partial(hook, callback)), **data)
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
data = {
'vid':
view.id(),
'file_path':
view.file_name(),
'parse_comments':
get_settings(view, 'anaconda_go_motion_parse_comments', False),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method':
self.method,
'handler':
'anaGonda'
}
Worker().execute(
Callback(on_success=ExplorerPanel(view).run,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', ' ')))
print(err)
def _run(self) -> None:
try:
if get_settings(
self.window.active_view(),
'anaconda_go_packages_cache_persistence', False):
cache.load_package_cache()
self.env = os.environ.copy()
self.env.update({'GOROOT': go.GOROOT, 'GOPATH': go.GOPATH})
gocmd = os.path.join(go.GOROOT, 'bin', 'go')
golist = create_subprocess(
shlex.split(gocmd + ' list -json all', posix=os.name != 'nt'),
stdout=PIPE, stdin=PIPE, env=self.env
)
msg = 'Getting list of golang packages from the system...\n'
self.print_to_panel(msg)
out, err = golist.communicate()
if err is not None and len(err) > 0:
self.print_to_panel(err.decode('utf8'))
self.pbar.terminate(status=self.pbar.Status.FAILURE)
return
self.process(out.decode('utf8'))
except:
print(traceback.print_exc())
def _run(self) -> None:
try:
if get_settings(self.window.active_view(),
'anaconda_go_packages_cache_persistence', False):
cache.load_package_cache()
self.env = os.environ.copy()
self.env.update({'GOROOT': go.GOROOT, 'GOPATH': go.GOPATH})
gocmd = os.path.join(go.GOROOT, 'bin', 'go')
golist = create_subprocess(shlex.split(gocmd + ' list -json all',
posix=os.name != 'nt'),
stdout=PIPE,
stdin=PIPE,
env=self.env)
msg = 'Getting list of golang packages from the system...\n'
self.print_to_panel(msg)
out, err = golist.communicate()
if err is not None and len(err) > 0:
self.print_to_panel(err.decode('utf8'))
self.pbar.terminate(status=self.pbar.Status.FAILURE)
return
self.process(out.decode('utf8'))
except:
print(traceback.print_exc())
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
data = {
'vid': view.id(),
'file_path': view.file_name(),
'offset': view.sel()[0].begin(),
'parse_comments': get_settings(
view, 'anaconda_go_motion_parse_comments', False
),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'enclosing',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: enclosing function error')
print(err)
def run(self, edit: sublime.Edit) -> None:
try:
view = self.view
scope = get_settings(view, 'anaconda_go_guru_scope')
row, col = view.rowcol(view.sel()[0].begin())
offset = view.text_point(row, col)
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid': view.id(),
'scope': scope if scope is not None else get_scope(view, go.GOPATH), # noqa
'path': view.file_name(),
'offset': offset,
'modified_buffer': self._modified_buffer(view, code),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'callstack',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except:
print('anaconda_go: callers error')
print(traceback.print_exc())
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
scope = get_settings(view, 'anaconda_go_guru_scope')
row, col = view.rowcol(view.sel()[0].begin())
offset = view.text_point(row, col)
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid': view.id(),
'scope': scope if scope is not None else get_scope(view, go.GOPATH), # noqa
'path': view.file_name(),
'offset': offset,
'modified_buffer': self._modified_buffer(view, code),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'implements',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
), **data
)
except:
print('anaconda_go: implements error')
print(traceback.print_exc())
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
scope = get_settings(view, 'anaconda_go_guru_scope')
data = {
'vid': view.id(),
'scope': scope if scope is not None else get_scope(view, go.GOPATH), # noqa
'code': view.substr(sublime.Region(0, view.size())),
'path': view.file_name(),
'buf': self.modified_buffer(view),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'get_package_decls',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=ExplorerPanel(view).run,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', ' ')))
print(err)
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
scope = get_settings(view, 'anaconda_go_guru_scope')
data = {
'vid': view.id(),
'scope': scope if scope is not None else get_scope(
view, go.GOPATH), # noqa
'code': view.substr(sublime.Region(0, view.size())),
'path': view.file_name(),
'buf': self.modified_buffer(view),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'get_package_decls',
'handler': 'anaGonda'
}
Worker().execute(
Callback(on_success=ExplorerPanel(view).run,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: {}'.format(self.method.replace('_', ' ')))
print(err)
def get_formatter_cmd(self, name, path):
formatter = self.get_binary(name)
if not formatter:
raise RuntimeError('{} not found...'.format(name))
args = get_settings(self.view, 'anaconda_go_{}_args'.format(name), [])
args = [formatter] + args + [path]
return args
def get_formatter_cmd(self, name, path):
formatter = self.get_binary(name)
if not formatter:
raise RuntimeError('{} not found...'.format(name))
args = get_settings(self.view, 'anaconda_go_{}_args'.format(name), [])
args = [formatter] + args + [path]
return args
def _detect_in_configuration(self) -> bool:
"""Detect and validate Go parameters in configuration
"""
view = active_view()
goroot = get_settings(view, 'anaconda_go_GOROOT', '')
gopath = get_settings(view, 'anaconda_go_GOPATH', '')
gobin = get_settings(view, 'anaconda_go_GOBIN', '')
if goroot and gopath:
gobin = 'go' if os.name != 'nt' else 'go.exe'
if os.path.exists(os.path.join(goroot, 'bin', gobin)):
self.GOROOT = goroot
self.GOPATH = gopath
self.GOBIN = gobin
self.CGO_ENABLED = "1"
return True
return False
def run(self, package: bool = False, callstack: bool = False) -> None:
if package is True:
self.run_for_packages()
return
try:
view = self.window.active_view()
self.view = view
row, col = view.rowcol(view.sel()[0].begin())
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid':
view.id(),
'path':
view.file_name(),
'expr':
get_symbol(code, row, col),
'private':
get_settings(view, 'anaconda_go_doc_private_symbols', False),
'force':
get_settings(view, 'anaconda_go_force_go_doc_usage', False),
'offset':
view.text_point(*view.rowcol(view.sel()[0].begin())),
'buf':
self.modified_buffer(view),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED,
'GO_VERSION': self.go_version
},
'method':
'doc',
'handler':
'anaGonda'
}
Worker().execute(
Callback(on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: go doc error')
print(traceback.print_exc())
def _detect_in_configuration(self) -> bool:
"""Detect and validate Go parameters in configuration
"""
view = active_view()
goroot = get_settings(view, 'anaconda_go_GOROOT', '')
gopath = get_settings(view, 'anaconda_go_GOPATH', '')
gobin = get_settings(view, 'anaconda_go_GOBIN', '')
if goroot and gopath:
gobin = 'go' if os.name != 'nt' else 'go.exe'
if os.path.exists(os.path.join(goroot, 'bin', gobin)):
self.GOROOT = goroot
self.GOPATH = gopath
self.GOBIN = gobin
self.CGO_ENABLED = "1"
return True
return False
def run(self, edit, path=None):
if path is None:
path = self.view.file_name()
code = self.view.substr(sublime.Region(0, self.view.size()))
try:
self.view.set_read_only(True)
use_goimports = get_settings(self.view, 'anaconda_go_format_with_goimports', True)
if use_goimports:
self.format('goimports', code, path, edit)
self.view.set_read_only(True)
use_gofmt = get_settings(self.view, 'anaconda_go_format_with_gofmt', False)
if use_gofmt:
self.format('gofmt', code, path, edit)
except Exception:
self.view.set_read_only(False)
raise
finally:
self.view.set_read_only(False)
def run_linter(view=None, hook=None):
"""Wrapper to run the right linter
"""
if not go.ANAGONDA_PRESENT:
return
if get_settings(view, 'anaconda_go_fast_linters_only', False):
fast_linters(view, hook)
else:
all_linters(view, hook)
def on_pre_save(self, view: sublime_plugin.sublime.View) -> None:
"""Called just before the file is going to be saved
"""
if time.time() - self._last_save < 2:
return
auto_format = get_settings(view, 'anaconda_go_auto_format', False)
if auto_format and is_code(view, lang='go'):
view.run_command('anaconda_go_format')
self._last_save = time.time()
def run(self, package: bool=False, callstack: bool=False) -> None:
if package is True:
self.run_for_packages()
return
try:
view = self.window.active_view()
self.view = view
row, col = view.rowcol(view.sel()[0].begin())
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid': view.id(),
'path': view.file_name(),
'expr': get_symbol(code, row, col),
'private': get_settings(
view, 'anaconda_go_doc_private_symbols', False),
'force': get_settings(
view, 'anaconda_go_force_go_doc_usage', False),
'offset': view.text_point(*view.rowcol(view.sel()[0].begin())),
'buf': self.modified_buffer(view),
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED,
'GO_VERSION': self.go_version
},
'method': 'doc',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: go doc error')
print(traceback.print_exc())
def run(self, edit, path=None):
if path is None:
path = self.view.file_name()
code = self.view.substr(sublime.Region(0, self.view.size()))
try:
self.view.set_read_only(True)
use_goimports = get_settings(self.view,
'anaconda_go_format_with_goimports',
True)
if use_goimports:
self.format('goimports', code, path, edit)
self.view.set_read_only(True)
use_gofmt = get_settings(self.view,
'anaconda_go_format_with_gofmt', False)
if use_gofmt:
self.format('gofmt', code, path, edit)
except Exception:
self.view.set_read_only(False)
raise
finally:
self.view.set_read_only(False)
def update_buffer(self, edit):
"""Update and reload the buffer
"""
results = self.data.get('result')
view = get_window_view(self.data['vid'])
if results is not None and results != '' and self.code != results:
region = sublime.Region(0, view.size())
view.replace(edit, region, results)
if get_settings(view, 'anaconda_go_auto_format'):
view.run_command('save')
# sublime.set_timeout(lambda: view.run_command('save'), 0)
self.data = None
self.code = None
def _get_settings(view):
return {
'linters': get_settings(view, 'anaconda_go_linters', []),
'lint_test': get_settings(
view, 'anaconda_go_lint_test', False),
'exclude_regexps': get_settings(
view, 'anaconda_go_exclude_regexps', []),
'max_line_length': get_settings(
view, 'anaconda_go_max_line_length', 120),
'gocyclo_threshold': get_settings(
view, 'anaconda_go_gocyclo_threshold', 10),
'golint_min_confidence': get_settings(
view, 'anaconda_go_golint_min_confidence', 0.80),
'goconst_min_occurrences': get_settings(
view, 'anaconda_go_goconst_min_occurrences', 3),
'min_const_length': get_settings(
view, 'anaconda_go_min_const_length', 3),
'dupl_threshold': get_settings(
view, 'anaconda_go_dupl_threshold', 50),
'path': os.path.dirname(view.file_name())
}
def on_pre_save(self, view: sublime_plugin.sublime.View) -> None:
"""Called just before the file is going to be saved
"""
if time.time() - self._last_save < 2:
return
auto_format = get_settings(view, 'anaconda_go_auto_format', False)
if auto_format and is_code(view, lang='go'):
filename = os.path.join(tempfile.gettempdir(), view.file_name())
buf = view.substr(sublime.Region(0, view.size()))
self._save_tmp_buffer(buf, filename)
view.run_command('anaconda_go_format_sync',
args={"path": filename})
self._remove_tmp_buffer(filename)
AnacondaGoAutoFormatEventListener._last_save = time.time()
def on_pre_save(self, view: sublime_plugin.sublime.View) -> None:
"""Called just before the file is going to be saved
"""
if time.time() - self._last_save < 2:
return
auto_format = get_settings(view, 'anaconda_go_auto_format', False)
if auto_format and is_code(view, lang='go'):
filename = os.path.join(tempfile.gettempdir(), view.file_name())
buf = view.substr(sublime.Region(0, view.size()))
self._save_tmp_buffer(buf, filename)
view.run_command(
'anaconda_go_format_sync', args={"path": filename}
)
self._remove_tmp_buffer(filename)
AnacondaGoAutoFormatEventListener._last_save = time.time()
def _on_select(self, index: int) -> None:
"""Called when a package is selected from the quick panel
"""
if index == -1:
return
package = self._packages[index]
try:
view = self.window.active_view()
self.view = view
data = {
'vid':
view.id(),
'path':
view.file_name(),
'expr':
package,
'private':
get_settings(view, 'anaconda_go_doc_private_symbols', False),
'force':
True,
'offset':
0,
'buf':
'',
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED,
'GO_VERSION': self.go_version
},
'method':
'doc',
'handler':
'anaGonda'
}
Worker().execute(
Callback(on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: go doc error')
print(traceback.print_exc())
def run(self, standalone=False) -> None:
panel = self.window.create_output_panel('browse')
panel.settings().set('wrap_width', 120)
panel.settings().set("scroll_past_end", False)
panel.assign_syntax('Packages/Text/Plain text.tmLanguage')
self.output = panel
self.window.create_output_panel('browse')
if standalone or get_settings(
self.window.active_view(), 'anaconda_go_verbose', True):
self.window.run_command('show_panel', {'panel': 'output.browse'})
sublime.set_timeout_async(lambda: self._run(), 0)
messages = {
'start': 'Building packages navigation cache...',
'end': 'done!',
'fail': 'The package navigation cache could not be build!',
'timeout': ''
}
self.pbar = ProgressBar(messages)
self.pbar.start()
def run(self, standalone=False) -> None:
panel = self.window.create_output_panel('browse')
panel.settings().set('wrap_width', 120)
panel.settings().set("scroll_past_end", False)
panel.assign_syntax('Packages/Text/Plain text.tmLanguage')
self.output = panel
self.window.create_output_panel('browse')
if standalone or get_settings(self.window.active_view(),
'anaconda_go_verbose', True):
self.window.run_command('show_panel', {'panel': 'output.browse'})
sublime.set_timeout_async(lambda: self._run(), 0)
messages = {
'start': 'Building packages navigation cache...',
'end': 'done!',
'fail': 'The package navigation cache could not be build!',
'timeout': ''
}
self.pbar = ProgressBar(messages)
self.pbar.start()
def _on_success(self, data):
"""Process result and normalize it for anaconda's goto
"""
if get_settings(self.view, 'anaconda_go_print_callstack', True):
# print the callstack in a doc panel
panel = panels.DocPanel(self.view)
panel.show()
panel.print(self._pretiffy(data))
callstack = []
for result in data['result'].get('callers', []):
f, l, c = result['pos'].split(':')
callstack.append({
'title': result['caller'],
'location': 'File: {} Line: {} Column: {}'.format(f, l, c),
'position': result['pos']
})
ExplorerPanel(self.view, callstack).show([])
def _on_select(self, index: int) -> None:
"""Called when a package is selected from the quick panel
"""
if index == -1:
return
package = self._packages[index]
try:
view = self.window.active_view()
self.view = view
data = {
'vid': view.id(),
'path': view.file_name(),
'expr': package,
'private': get_settings(
view, 'anaconda_go_doc_private_symbols', False),
'force': True,
'offset': 0,
'buf': '',
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED,
'GO_VERSION': self.go_version
},
'method': 'doc',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self.on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: go doc error')
print(traceback.print_exc())
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
row, col = view.rowcol(view.sel()[0].begin())
offset = view.text_point(row, col)
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid': view.id(),
'code': code,
'path': view.file_name(),
'settings': {
'offset': offset,
'expr': get_symbol(code, row, col),
'modified_buffer': self._modified_buffer(view, code),
'guru_usage': get_settings(
view, 'anaconda_go_guru_usage', 'always'
)
},
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'goto',
'handler': 'anaGonda'
}
Worker().execute(
Callback(
on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout
),
**data
)
except Exception as err:
print('anaconda_go: goto error')
print(traceback.print_exc())
def run(self) -> None:
try:
view = self.window.active_view()
self.view = view
row, col = view.rowcol(view.sel()[0].begin())
offset = view.text_point(row, col)
code = view.substr(sublime.Region(0, view.size()))
data = {
'vid': view.id(),
'code': code,
'path': view.file_name(),
'settings': {
'offset':
offset,
'expr':
get_symbol(code, row, col),
'modified_buffer':
self._modified_buffer(view, code),
'guru_usage':
get_settings(view, 'anaconda_go_guru_usage', 'always')
},
'go_env': {
'GOROOT': go.GOROOT,
'GOPATH': go.GOPATH,
'CGO_ENABLED': go.CGO_ENABLED
},
'method': 'goto',
'handler': 'anaGonda'
}
Worker().execute(
Callback(on_success=self._on_success,
on_failure=self._on_failure,
on_timeout=self._on_timeout), **data)
except Exception as err:
print('anaconda_go: goto error')
print(traceback.print_exc())
def process(self, data: str) -> None:
"""Process the output from go list (that is not valid JSON btw)
"""
gurucmd = os.path.join(go.GOPATH, 'bin', 'guru')
json_data = json.loads('[' + data.replace('}\n{', '},\n{') + ']')
for package in json_data:
self.print_to_panel('{} -> '.format(package['ImportPath']))
if cache.package_in_cache(package):
self.print_to_panel('already in cache, nothing to do\n')
continue
try:
fname = os.path.join(package['Dir'], package['GoFiles'][0])
args = []
kwargs = {}
if os.name == 'posix':
args = 'grep -b "package {}" {}'.format(
package['Name'], fname
)
else:
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
kwargs['startupinfo'] = startupinfo
args = shlex.split(
'findstr /O /R /C:"package {}" {}'.format(
package['Name'], fname
), posix=False
)
grep = check_output(args, shell=True, **kwargs)
except Exception as error:
self.print_to_panel(str(error))
continue
try:
offset = int(grep.decode().split(':')[0]) + len('package ') + 1
except Exception as e:
print('while parsing grep/findstr output for {}: {}\t{}'.format( # noqa
' '.join(args), e, grep.decode())
)
continue
args = shlex.split('{} -json -scope {} describe {}:#{}'.format(
gurucmd, package['ImportPath'], fname, offset)
)
guru = create_subprocess(
args, stdout=PIPE, stderr=PIPE, env=self.env)
out, err = guru.communicate()
if err is not None and len(err) > 0:
self.print_to_panel(err.decode('utf8'))
continue
self.print_to_panel('Done\n')
package['Guru'] = json.loads(out.decode('utf8'))
cache.append(package)
self.pbar.terminate()
if get_settings(
self.window.active_view(),
'anaconda_go_packages_cache_persistence', False):
cache.persist_package_cache()
self.print_to_panel(
'\nPackages browse cache loaded, set the option '
'"anaconda_go_verbose" as "false" in the configuration '
'if you do not want to see this panel everytime that you '
'start your Sublime Text 3\n\n'
'Note: you can generate this cache at any time using the '
'Command Palette'
)
def process(self, data: str) -> None:
"""Process the output from go list (that is not valid JSON btw)
"""
gurucmd = os.path.join(go.GOPATH, 'bin', 'guru')
json_data = json.loads('[' + data.replace('}\n{', '},\n{') + ']')
for package in json_data:
self.print_to_panel('{} -> '.format(package['ImportPath']))
if cache.package_in_cache(package):
self.print_to_panel('already in cache, nothing to do\n')
continue
try:
fname = os.path.join(package['Dir'], package['GoFiles'][0])
args = []
kwargs = {}
if os.name == 'posix':
args = 'grep -b "package {}" {}'.format(
package['Name'], fname)
else:
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
kwargs['startupinfo'] = startupinfo
args = shlex.split(
'findstr /O /R /C:"package {}" {}'.format(
package['Name'], fname),
posix=False)
grep = check_output(args, shell=True, **kwargs)
except Exception as error:
self.print_to_panel(str(error))
continue
try:
offset = int(grep.decode().split(':')[0]) + len('package ') + 1
except Exception as e:
print('while parsing grep/findstr output for {}: {}\t{}'.
format( # noqa
' '.join(args), e, grep.decode()))
continue
args = shlex.split('{} -json -scope {} describe {}:#{}'.format(
gurucmd, package['ImportPath'], fname, offset))
guru = create_subprocess(args,
stdout=PIPE,
stderr=PIPE,
env=self.env)
out, err = guru.communicate()
if err is not None and len(err) > 0:
self.print_to_panel(err.decode('utf8'))
continue
self.print_to_panel('Done\n')
package['Guru'] = json.loads(out.decode('utf8'))
cache.append(package)
self.pbar.terminate()
if get_settings(self.window.active_view(),
'anaconda_go_packages_cache_persistence', False):
cache.persist_package_cache()
self.print_to_panel(
'\nPackages browse cache loaded, set the option '
'"anaconda_go_verbose" as "false" in the configuration '
'if you do not want to see this panel everytime that you '
'start your Sublime Text 3\n\n'
'Note: you can generate this cache at any time using the '
'Command Palette')
