def on_query_completions(self, view, prefix, locations):
if not GoBuffers.is_go_source(view): return
if not golangconfig.setting_value("autocomplete")[0]: return
gocodeFlag = ["-f=json", "-sock=none"] if golangconfig.setting_value(
"gocode_client_mode")[0] else ["-f=json"]
suggestionsJsonStr, stderr, rc = ToolRunner.run(
view,
"gocode",
gocodeFlag + ["autocomplete",
view.file_name(),
str(locations[0])],
stdin=Buffers.buffer_text(view))
suggestionsJson = json.loads(suggestionsJsonStr)
Logger.log("DEBUG: gocode output: " + suggestionsJsonStr)
if rc != 0:
Logger.status("no completions found: " + str(e))
return []
if len(suggestionsJson) > 0:
return ([
GotoolsSuggestions.build_suggestion(j)
for j in suggestionsJson[1]
], sublime.INHIBIT_WORD_COMPLETIONS)
else:
return []
def run(self):
"""
Runs the "golang_build_terminal" command - invoked by Sublime Text via
the command palette or sublime.Window.run_command()
"""
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
relevant_sources = set([
'project file',
'project file (os-specific)',
'golang.sublime-settings',
'golang.sublime-settings (os-specific)'
])
env_overrides = {}
for var_name in GO_ENV_VARS:
value, source = golangconfig.setting_value(var_name, window=self.window)
# Only set overrides that are not coming from the user's shell
if source in relevant_sources:
env_overrides[var_name] = value
# Get the PATH from the shell environment and then prepend any custom
# value so the user's terminal searches all locations
value, source = golangconfig.setting_value('PATH', window=self.window)
if source in relevant_sources:
shell, env = shellenv.get_env()
env_overrides['PATH'] = value + os.pathsep + env.get('PATH', '')
newterm.launch_terminal(working_dir, env=env_overrides)
def run(self):
"""
Runs the "golang_build_terminal" command - invoked by Sublime Text via
the command palette or sublime.Window.run_command()
"""
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
relevant_sources = set([
'project file', 'project file (os-specific)',
'golang.sublime-settings', 'golang.sublime-settings (os-specific)'
])
env_overrides = {}
for var_name in GO_ENV_VARS:
value, source = golangconfig.setting_value(var_name,
window=self.window)
# Only set overrides that are not coming from the user's shell
if source in relevant_sources:
env_overrides[var_name] = value
# Get the PATH from the shell environment and then prepend any custom
# value so the user's terminal searches all locations
value, source = golangconfig.setting_value('PATH', window=self.window)
if source in relevant_sources:
shell, env = shellenv.get_env()
env_overrides['PATH'] = value + os.pathsep + env.get('PATH', '')
newterm.launch_terminal(working_dir, env=env_overrides)
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(
self.view)
if command == "freevars":
pos = filename + ":#" + str(offset) + "," + "#" + str(offset_end)
else:
pos = filename + ":#" + str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
package_scope = []
project_package = golangconfig.setting_value("project_package",
view=self.view)[0]
if project_package:
for p in golangconfig.setting_value("build_packages",
view=self.view)[0]:
package_scope.append(os.path.join(project_package, p))
sublime.active_window().run_command("hide_panel",
{"panel": "output.gotools_guru"})
self.do_plain_guru(command, pos, package_scope)
def run(self, edit):
command = ""
args = []
if golangconfig.setting_value("format_backend")[0] == "gofmt":
command = "gofmt"
args = ["-e", "-s"]
elif golangconfig.setting_value("format_backend")[0] in ["goimports", "both"] :
command = "goimports"
args = ["-e", "-srcdir=%s" % os.path.dirname(self.view.file_name())]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=Buffers.buffer_text(self.view))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
Logger.err = True
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
return
if golangconfig.setting_value("format_backend")[0] == "both":
command = "gofmt"
args = ["-e", "-s"]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=stdout.encode('utf-8'))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
Logger.err = True
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
return
# Everything's good, hide the syntax error panel
self.view.window().run_command("hide_panel", {"panel": "output.gotools_syntax_errors"})
# Remember the viewport position. When replacing the buffer, Sublime likes to jitter the
# viewport around for some reason.
self.prev_viewport_pos = self.view.viewport_position()
# Replace the buffer with gofmt output.
self.view.replace(edit, sublime.Region(0, self.view.size()), stdout)
# Restore the viewport on the main GUI thread (which is the only way this works).
sublime.set_timeout(self.restore_viewport, 0)
Logger.err = False
def run(self, edit):
command = ""
args = []
if golangconfig.setting_value('format_backend')[0] == "gofmt":
command = "gofmt"
args = ["-e", "-s"]
elif golangconfig.setting_value('format_backend')[0] in [
"goimports", "both"
]:
command = "goimports"
args = ["-e"]
stdout, stderr, rc = ToolRunner.run(self.view,
command,
args,
stdin=Buffers.buffer_text(
self.view))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" +
stderr)
self.phantom_set.update([])
return
if golangconfig.setting_value('format_backend')[0] == "both":
command = "gofmt"
args = ["-e", "-s"]
stdout, stderr, rc = ToolRunner.run(self.view,
command,
args,
stdin=stdout.encode('utf-8'))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" +
stderr)
self.phantom_set.update([])
return
# Everything's good, hide the syntax error panel
self.phantom_set.update([])
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(
self.view)
pos = filename + ":#" + str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
# TODO: put into a utility
package_scope = []
project_pkg = golangconfig.setting_value('project_package')[0] or ""
for p in golangconfig.setting_value('build_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
for p in golangconfig.setting_value('test_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
for p in golangconfig.setting_value('tagged_test_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
sublime.active_window().run_command("hide_panel",
{"panel": "output.gotools_oracle"})
if command == "callees":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("callees", pos, package_scope), 0)
if command == "callers":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("callers", pos, package_scope), 0)
if command == "callstack":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("callstack", pos, package_scope),
0)
if command == "describe":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("describe", pos, package_scope),
0)
if command == "freevars":
pos = filename + ":#" + str(offset) + "," + "#" + str(offset_end)
sublime.set_timeout_async(
lambda: self.do_plain_oracle("freevars", pos, package_scope),
0)
if command == "implements":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("implements", pos, package_scope),
0)
if command == "peers":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("peers", pos, package_scope), 0)
if command == "referrers":
sublime.set_timeout_async(
lambda: self.do_plain_oracle("referrers", pos, package_scope),
0)
def run(self, edit):
command = ""
args = []
if golangconfig.setting_value("format_backend")[0] == "gofmt":
command = "gofmt"
args = ["-e", "-s"]
elif golangconfig.setting_value("format_backend")[0] in ["goimports", "both"] :
command = "goimports"
args = ["-e"]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=Buffers.buffer_text(self.view))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
return
if golangconfig.setting_value("format_backend")[0] == "both":
command = "gofmt"
args = ["-e", "-s"]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=stdout.encode('utf-8'))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
return
# Everything's good, hide the syntax error panel
self.view.window().run_command("hide_panel", {"panel": "output.gotools_syntax_errors"})
# Remember the viewport position. When replacing the buffer, Sublime likes to jitter the
# viewport around for some reason.
self.prev_viewport_pos = self.view.viewport_position()
# Replace the buffer with gofmt output.
self.view.replace(edit, sublime.Region(0, self.view.size()), stdout)
# Restore the viewport on the main GUI thread (which is the only way this works).
sublime.set_timeout(self.restore_viewport, 0)
def run(self, edit):
if golangconfig.setting_value("lint_backend")[0] == "golint":
self.run_golint()
elif golangconfig.setting_value("lint_backend")[0] == "govet":
self.run_govet()
elif golangconfig.setting_value("lint_backend")[0] == "both":
rc = self.run_govet()
if rc != 1:
self.run_golint()
else:
sublime.error_message("Must choose a linter: govet or golint or both")
return
def run(self, edit):
if golangconfig.setting_value("lint_backend")[0] == "golint":
self.run_golint()
elif golangconfig.setting_value("lint_backend")[0] == "govet":
self.run_govet()
elif golangconfig.setting_value("lint_backend")[0] == "both":
rc = self.run_govet()
if rc != 1:
self.run_golint()
else:
sublime.error_message(
"Must choose a linter: govet or golint or both")
return
def run(self, edit, event=None):
# Find and store the current filename and byte offset at the
# cursor or mouse event location.
if event:
filename, row, col, offset = Buffers.location_for_event(self.view, event)
else:
filename, row, col, offset, offset_end = Buffers.location_at_cursor(self.view)
backend = golangconfig.setting_value('goto_def_backend')[0] or "godef"
try:
if backend == "oracle":
file, row, col = self.get_oracle_location(filename, offset)
elif backend == "godef":
file, row, col = self.get_godef_location(filename, offset)
else:
Logger.log("Invalid godef backend '" + backend + "' (supported: godef, oracle)")
Logger.status("Invalid godef configuration; see console log for details")
return
except Exception as e:
Logger.status(str(e))
return
if not os.path.isfile(file):
Logger.log("WARN: file indicated by godef not found: " + file)
Logger.status("godef failed: Please enable debugging and check console log")
return
Logger.log("opening definition at " + file + ":" + str(row) + ":" + str(col))
w = self.view.window()
new_view = w.open_file(file + ':' + str(row) + ':' + str(col), sublime.ENCODED_POSITION)
group, index = w.get_view_index(new_view)
if group != -1:
w.focus_group(group)
def run(self, edit):
command = ""
args = []
if golangconfig.setting_value('format_backend')[0] == "gofmt":
command = "gofmt"
args = ["-e", "-s"]
elif golangconfig.setting_value('format_backend')[0] in ["goimports", "both"]:
command = "goimports"
args = ["-e"]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=Buffers.buffer_text(self.view))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
self.phantom_set.update([])
return
if golangconfig.setting_value('format_backend')[0] == "both":
command = "gofmt"
args = ["-e", "-s"]
stdout, stderr, rc = ToolRunner.run(self.view, command, args, stdin=stdout.encode('utf-8'))
# Clear previous syntax error marks
self.view.erase_regions("mark")
if rc == 2:
# Show syntax errors and bail
self.show_syntax_errors(stderr)
return
if rc != 0:
# Ermmm...
Logger.log("unknown gofmt error (" + str(rc) + ") stderr:\n" + stderr)
self.phantom_set.update([])
return
# Everything's good, hide the syntax error panel
self.phantom_set.update([])
def run(self, url=None, flags=None):
"""
Runs the "golang_build_get" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param url:
A unicode string of the URL to download, instead of prompting the
user
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. Execute "go help" on the command line to learn about available
flags.
"""
if _yeild_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
'go',
set(['GOPATH']),
GO_ENV_VARS - set(['GOPATH']),
view=self.window.active_view(),
window=self.window,
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value(
'get:flags',
view=self.window.active_view(),
window=self.window)
def on_done(get_url):
"""
Processes the user's input and launches the "go get" command
:param get_url:
A unicode string of the URL to get
"""
args = [go_bin, 'get', '-v']
if flags and isinstance(flags, list):
args.extend(flags)
args.append(get_url)
proc = _run_process('get', self.window, args, working_dir, env)
_set_proc(self.window, proc)
if url is not None:
on_done(url)
return
self.window.show_input_panel('go get', '', on_done, None, None)
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(
self.view)
if command == "freevars":
pos = filename + ":#" + str(offset) + "," + "#" + str(offset_end)
else:
pos = filename + ":#" + str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
package_scope = []
project_package = golangconfig.setting_value("project_package",
view=self.view)[0]
if project_package:
if not golangconfig.setting_value("build_packages")[0]:
package_scope.append(project_package)
else:
for p in golangconfig.setting_value("build_packages",
view=self.view)[0]:
package_scope.append(os.path.join(project_package, p))
# add local package to guru scope
if golangconfig.setting_value("guru_use_current_package")[0]:
current_file_path = os.path.realpath(
os.path.dirname(self.view.file_name()))
toolpath, env = golangconfig.subprocess_info('guru',
['GOPATH', 'PATH'],
view=self.view)
GOPATH = os.path.realpath(env["GOPATH"])
GOPATH = os.path.join(GOPATH, "src")
local_package = os.path.relpath(current_file_path, GOPATH)
if sublime.platform() == 'windows':
local_package = local_package.replace('\\', '/')
Logger.status("GOPATH: " + GOPATH)
Logger.status("local_package: " + local_package)
package_scope.append(local_package)
sublime.active_window().run_command("hide_panel",
{"panel": "output.gotools_guru"})
self.do_plain_guru(command, pos, package_scope)
def test_setting_value_gopath_not_string(self):
shell = '/bin/bash'
env = {'GOPATH': 1}
with GolangConfigMock(shell, env, None, None,
{'debug': True}) as mock_context:
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view,
mock_context.window))
self.assertTrue('is not a string' in sys.stdout.getvalue())
def setting_value_gopath(self, shell, env, view_settings, window_settings,
sublime_settings, setting, result):
with GolangConfigMock(shell, env, view_settings, window_settings,
sublime_settings) as mock_context:
self.assertEquals(
result,
golangconfig.setting_value(setting, mock_context.view,
mock_context.window))
self.assertEqual('', sys.stdout.getvalue())
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(self.view)
pos = filename + ":#" + str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
# TODO: put into a utility
package_scope = []
project_pkg = golangconfig.setting_value('project_package')[0] or ""
for p in golangconfig.setting_value('build_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
for p in golangconfig.setting_value('test_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
for p in golangconfig.setting_value('tagged_test_packages'):
if p:
package_scope.append(os.path.join(project_pkg, p))
sublime.active_window().run_command("hide_panel", {"panel": "output.gotools_oracle"})
if command == "callees":
sublime.set_timeout_async(lambda: self.do_plain_oracle("callees", pos, package_scope), 0)
if command == "callers":
sublime.set_timeout_async(lambda: self.do_plain_oracle("callers", pos, package_scope), 0)
if command == "callstack":
sublime.set_timeout_async(lambda: self.do_plain_oracle("callstack", pos, package_scope), 0)
if command == "describe":
sublime.set_timeout_async(lambda: self.do_plain_oracle("describe", pos, package_scope), 0)
if command == "freevars":
pos = filename + ":#" + str(offset) + "," + "#" + str(offset_end)
sublime.set_timeout_async(lambda: self.do_plain_oracle("freevars", pos, package_scope), 0)
if command == "implements":
sublime.set_timeout_async(lambda: self.do_plain_oracle("implements", pos, package_scope), 0)
if command == "peers":
sublime.set_timeout_async(lambda: self.do_plain_oracle("peers", pos, package_scope), 0)
if command == "referrers":
sublime.set_timeout_async(lambda: self.do_plain_oracle("referrers", pos, package_scope), 0)
def test_setting_value_gopath_not_existing(self):
shell = '/bin/bash'
env = {
'GOPATH': os.path.join(os.path.expanduser('~'), 'hdjsahkjzhkjzhiashs7hdsuybyusbguycas')
}
with GolangConfigMock(shell, env, None, None, {'debug': True}) as mock_context:
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view, mock_context.window)
)
self.assertTrue('does not exist on the filesystem' in sys.stdout.getvalue())
def test_setting_value_gopath_not_string(self):
shell = '/bin/bash'
env = {
'GOPATH': 1
}
with GolangConfigMock(shell, env, None, None, {'debug': True}) as mock_context:
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view, mock_context.window)
)
self.assertTrue('is not a string' in sys.stdout.getvalue())
def run(self, url=None, flags=None):
"""
Runs the "golang_build_get" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param url:
A unicode string of the URL to download, instead of prompting the
user
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. Execute "go help" on the command line to learn about available
flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
"go", set(["GOPATH"]), GO_ENV_VARS - set(["GOPATH"]), view=self.window.active_view(), window=self.window
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value("get:flags", view=self.window.active_view(), window=self.window)
if flags is None:
flags = ["-v"]
def on_done(get_url):
"""
Processes the user's input and launches the "go get" command
:param get_url:
A unicode string of the URL to get
"""
args = [go_bin, "get"]
if flags and isinstance(flags, list):
args.extend(flags)
args.append(get_url)
proc = _run_process("get", self.window, args, working_dir, env)
_set_proc(self.window, proc)
if url is not None:
on_done(url)
return
self.window.show_input_panel("go get", "", on_done, None, None)
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(self.view)
if command == "freevars":
pos = filename+":#"+str(offset)+","+"#"+str(offset_end)
else:
pos = filename+":#"+str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
package_scope = []
project_package = golangconfig.setting_value("project_package", view=self.view)[0]
if project_package:
for p in golangconfig.setting_value("build_packages", view=self.view)[0]:
package_scope.append(os.path.join(project_package, p))
sublime.active_window().run_command("hide_panel", {"panel": "output.gotools_guru"})
self.do_plain_guru(command, pos, package_scope)
def test_setting_value_multiple_gopath(self):
shell = '/bin/bash'
env = {'GOPATH': '{tempdir}bin%s{tempdir}usr/bin' % os.pathsep}
with GolangConfigMock(shell, env, None, None,
{'debug': True}) as mock_context:
mock_context.replace_tempdir_env()
mock_context.make_dirs(['bin', 'usr/bin'])
self.assertEquals(
(env['GOPATH'], shell),
golangconfig.setting_value('GOPATH', mock_context.view,
mock_context.window))
self.assertEqual('', sys.stdout.getvalue())
def get_oracle_location(self, filename, offset):
args = ["-pos="+filename+":#"+str(offset), "-format=json", "definition"]
# Build up a package scope contaning all packages the user might have
# configured.
# TODO: put into a utility
package_scope = []
for p in golangconfig.setting_value('build_packages')[0]:
package_scope.append(os.path.join(golangconfig.setting_value('project_package')[0], p))
for p in golangconfig.setting_value('test_packages')[0]:
package_scope.append(os.path.join(golangconfig.setting_value('project_package')[0], p))
for p in golangconfig.setting_value('tagged_test_packages')[0]:
package_scope.append(os.path.join(golangconfig.setting_value('project_package')[0], p))
if len(package_scope) > 0:
args = args + package_scope
location, err, rc = ToolRunner.run(self.view, "oracle", args)
if rc != 0:
raise Exception("no definition found")
Logger.log("oracle output:\n" + location.rstrip())
# cut anything prior to the first path separator
location = json.loads(location.rstrip())['definition']['objpos'].rsplit(":", 2)
if len(location) != 3:
raise Exception("no definition found")
file = location[0]
row = int(location[1])
col = int(location[2])
return [file, row, col]
def run(self, task='build', flags=None):
"""
Runs the "golang_build" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param task:
A unicode string of "build", "test", "install", "clean"
or "cross_compile"
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. The "cross_compile" task executes the "build" command with
the GOOS and GOARCH environment variables set, meaning that
flags for "build" should be used with it. Execute "go help" on the
command line to learn about available flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
'go',
set(['GOPATH']),
GO_ENV_VARS - set(['GOPATH']),
view=self.window.active_view(),
window=self.window,
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value(
'%s:flags' % task,
view=self.window.active_view(),
window=self.window)
if flags is None:
flags = ['-v']
if task == 'cross_compile':
_task_cross_compile(self, go_bin, flags, working_dir, env)
return
args = [go_bin, task]
if flags and isinstance(flags, list):
args.extend(flags)
proc = _run_process(task, self.window, args, working_dir, env)
_set_proc(self.window, proc)
def test_setting_value_multiple_gopath_one_not_existing(self):
shell = '/bin/bash'
env = {
'GOPATH': '{tempdir}bin%s{tempdir}usr/bin' % os.pathsep
}
with GolangConfigMock(shell, env, None, None, {'debug': True}) as mock_context:
mock_context.replace_tempdir_env()
mock_context.make_dirs(['usr/bin'])
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view, mock_context.window)
)
self.assertTrue('one of the values for GOPATH' in sys.stdout.getvalue())
def test_setting_value_multiple_gopath(self):
shell = '/bin/bash'
env = {
'GOPATH': '{tempdir}bin%s{tempdir}usr/bin' % os.pathsep
}
with GolangConfigMock(shell, env, None, None, {'debug': True}) as mock_context:
mock_context.replace_tempdir_env()
mock_context.make_dirs(['bin', 'usr/bin'])
self.assertEquals(
(env['GOPATH'], shell),
golangconfig.setting_value('GOPATH', mock_context.view, mock_context.window)
)
self.assertEqual('', sys.stdout.getvalue())
def test_setting_value_multiple_gopath_one_not_existing(self):
shell = '/bin/bash'
env = {'GOPATH': '{tempdir}bin%s{tempdir}usr/bin' % os.pathsep}
with GolangConfigMock(shell, env, None, None,
{'debug': True}) as mock_context:
mock_context.replace_tempdir_env()
mock_context.make_dirs(['usr/bin'])
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view,
mock_context.window))
self.assertTrue(
'one of the values for GOPATH' in sys.stdout.getvalue())
def run(self, edit, command=None):
if not command:
Logger.log("command is required")
return
filename, row, col, offset, offset_end = Buffers.location_at_cursor(self.view)
if command == "freevars":
pos = filename+":#"+str(offset)+","+"#"+str(offset_end)
else:
pos = filename+":#"+str(offset)
# Build up a package scope contaning all packages the user might have
# configured.
package_scope = []
project_package = golangconfig.setting_value("project_package", view=self.view)[0]
if project_package:
if not golangconfig.setting_value("build_packages")[0]:
package_scope.append(project_package)
else:
for p in golangconfig.setting_value("build_packages", view=self.view)[0]:
package_scope.append(os.path.join(project_package, p))
# add local package to guru scope
if golangconfig.setting_value("guru_use_current_package")[0]:
current_file_path = os.path.realpath(os.path.dirname(self.view.file_name()))
toolpath, env = golangconfig.subprocess_info('guru', ['GOPATH', 'PATH'], view=self.view)
GOPATH = os.path.realpath(env["GOPATH"])
GOPATH = os.path.join(GOPATH,"src")
local_package = os.path.relpath(current_file_path, GOPATH)
if sublime.platform() == 'windows':
local_package = local_package.replace('\\', '/')
Logger.status("GOPATH: "+GOPATH)
Logger.status("local_package: "+local_package)
package_scope.append(local_package)
sublime.active_window().run_command("hide_panel", {"panel": "output.gotools_guru"})
self.do_plain_guru(command, pos, package_scope)
def test_setting_value_gopath_not_existing(self):
shell = '/bin/bash'
env = {
'GOPATH':
os.path.join(os.path.expanduser('~'),
'hdjsahkjzhkjzhiashs7hdsuybyusbguycas')
}
with GolangConfigMock(shell, env, None, None,
{'debug': True}) as mock_context:
self.assertEquals(
(None, None),
golangconfig.setting_value('GOPATH', mock_context.view,
mock_context.window))
self.assertTrue(
'does not exist on the filesystem' in sys.stdout.getvalue())
def on_query_completions(self, view, prefix, locations):
if not GoBuffers.is_go_source(view): return
if not golangconfig.setting_value("autocomplete")[0]: return
suggestionsJsonStr, stderr, rc = ToolRunner.run(view, "gocode", ["-f=json", "autocomplete", view.file_name(), str(locations[0])], stdin=Buffers.buffer_text(view))
suggestionsJson = json.loads(suggestionsJsonStr)
Logger.log("DEBUG: gocode output: " + suggestionsJsonStr)
if rc != 0:
Logger.status("no completions found: " + str(e))
return []
if len(suggestionsJson) > 0:
return ([GotoolsSuggestions.build_suggestion(j) for j in suggestionsJson[1]], sublime.INHIBIT_WORD_COMPLETIONS)
else:
return []
def run(self, edit, event=None):
# Find and store the current filename and byte offset at the
# cursor or mouse event location.
if event:
filename, row, col, offset = Buffers.location_for_event(
self.view, event)
else:
filename, row, col, offset, offset_end = Buffers.location_at_cursor(
self.view)
backend = golangconfig.setting_value('goto_def_backend')[0] or "godef"
try:
if backend == "oracle":
file, row, col = self.get_oracle_location(filename, offset)
elif backend == "godef":
file, row, col = self.get_godef_location(filename, offset)
else:
Logger.log("Invalid godef backend '" + backend +
"' (supported: godef, oracle)")
Logger.status(
"Invalid godef configuration; see console log for details")
return
except Exception as e:
Logger.status(str(e))
return
if not os.path.isfile(file):
Logger.log("WARN: file indicated by godef not found: " + file)
Logger.status(
"godef failed: Please enable debugging and check console log")
return
Logger.log("opening definition at " + file + ":" + str(row) + ":" +
str(col))
w = self.view.window()
new_view = w.open_file(file + ':' + str(row) + ':' + str(col),
sublime.ENCODED_POSITION)
group, index = w.get_view_index(new_view)
if group != -1:
w.focus_group(group)
def get_oracle_location(self, filename, offset):
args = [
"-pos=" + filename + ":#" + str(offset), "-format=json",
"definition"
]
# Build up a package scope contaning all packages the user might have
# configured.
# TODO: put into a utility
package_scope = []
for p in golangconfig.setting_value('build_packages')[0]:
package_scope.append(
os.path.join(
golangconfig.setting_value('project_package')[0], p))
for p in golangconfig.setting_value('test_packages')[0]:
package_scope.append(
os.path.join(
golangconfig.setting_value('project_package')[0], p))
for p in golangconfig.setting_value('tagged_test_packages')[0]:
package_scope.append(
os.path.join(
golangconfig.setting_value('project_package')[0], p))
if len(package_scope) > 0:
args = args + package_scope
location, err, rc = ToolRunner.run(self.view, "oracle", args)
if rc != 0:
raise Exception("no definition found")
Logger.log("oracle output:\n" + location.rstrip())
# cut anything prior to the first path separator
location = json.loads(
location.rstrip())['definition']['objpos'].rsplit(":", 2)
if len(location) != 3:
raise Exception("no definition found")
file = location[0]
row = int(location[1])
col = int(location[2])
return [file, row, col]
def run(self, task='build', flags=None):
"""
Runs the "golang_build" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param task:
A unicode string of "build", "test", "benchmark", "install", "clean"
or "cross_compile"
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. The "cross_compile" task executes the "build" command with
the GOOS and GOARCH environment variables set, meaning that
flags for "build" should be used with it. Execute "go help" on the
command line to learn about available flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
'go',
set(['GOPATH']),
GO_ENV_VARS - set(['GOPATH']),
view=self.window.active_view(),
window=self.window,
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value(
'%s:flags' % task,
view=self.window.active_view(),
window=self.window)
if flags is None:
flags = ['-v']
if task == 'run':
# Allow the user to set a file path into the flags settings,
# thus requiring that the flags be checked to ensure a second
# filename is not added
found_filename = False
# Allow users to call "run" with a src-relative file path. Because
# of that, flags may be rewritten since the "go run" does not
# accept such file paths.
use_new_flags = False
new_flags = []
gopaths = env['GOPATH'].split(os.pathsep)
for flag in flags:
if flag.endswith('.go'):
absolute_path = flag
if os.path.isfile(absolute_path):
found_filename = True
break
# If the file path is src-relative, rewrite the flag
for gopath in gopaths:
gopath_relative = os.path.join(gopath, 'src', flag)
if os.path.isfile(gopath_relative):
found_filename = True
flag = gopath_relative
use_new_flags = True
break
new_flags.append(flag)
if use_new_flags:
flags = new_flags
if not found_filename:
flags.append(self.window.active_view().file_name())
if task == 'cross_compile':
_task_cross_compile(self, go_bin, flags, working_dir, env)
return
if task == 'benchmark':
# Switch back to the real Go command-line arg
task = 'test'
# Allow user to set a regexp for the benchmarks to run
found_bench_flag = False
# Need to match '-bench=xyz', ['-bench','xyz'], ['-bench','.']
# Don't match '-benchmem' or '-benchtime'
# Remember user can't specify spaces in flags
for flag in flags:
if flag == '-bench' or flag.startswith('-bench='):
found_bench_flag = True
# Otherwise default to running all benchmarks
if not found_bench_flag:
flags.append('-bench=.')
args = [go_bin, task]
if flags and isinstance(flags, list):
args.extend(flags)
proc = _run_process(task, self.window, args, working_dir, env)
_set_proc(self.window, proc)
def log(msg):
if golangconfig.setting_value('debug_enabled')[0]:
print("GoTools: DEBUG: {0}".format(msg))
def run(self, task='build', flags=None):
"""
Runs the "golang_build" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param task:
A unicode string of "build", "test", "install", "clean"
or "cross_compile"
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. The "cross_compile" task executes the "build" command with
the GOOS and GOARCH environment variables set, meaning that
flags for "build" should be used with it. Execute "go help" on the
command line to learn about available flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
'go',
set(['GOPATH']),
GO_ENV_VARS - set(['GOPATH']),
view=self.window.active_view(),
window=self.window,
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value(
'%s:flags' % task,
view=self.window.active_view(),
window=self.window
)
if flags is None:
flags = ['-v']
if task == 'cross_compile':
_task_cross_compile(
self,
go_bin,
flags,
working_dir,
env
)
return
args = [go_bin, task]
if flags and isinstance(flags, list):
args.extend(flags)
proc = _run_process(
task,
self.window,
args,
working_dir,
env
)
_set_proc(self.window, proc)
def run(self, task='build', flags=None):
"""
Runs the "golang_build" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param task:
A unicode string of "build", "test", "benchmark", "install", "clean"
or "cross_compile"
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. The "cross_compile" task executes the "build" command with
the GOOS and GOARCH environment variables set, meaning that
flags for "build" should be used with it. Execute "go help" on the
command line to learn about available flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
'go',
set(['GOPATH']),
GO_ENV_VARS - set(['GOPATH']),
view=self.window.active_view(),
window=self.window,
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value(
'%s:flags' % task,
view=self.window.active_view(),
window=self.window
)
if flags is None:
flags = ['-v']
if task == 'run':
# Allow the user to set a file path into the flags settings,
# thus requiring that the flags be checked to ensure a second
# filename is not added
found_filename = False
# Allow users to call "run" with a src-relative file path. Because
# of that, flags may be rewritten since the "go run" does not
# accept such file paths.
use_new_flags = False
new_flags = []
gopaths = env['GOPATH'].split(os.pathsep)
for flag in flags:
if flag.endswith('.go'):
absolute_path = flag
if os.path.isfile(absolute_path):
found_filename = True
break
# If the file path is src-relative, rewrite the flag
for gopath in gopaths:
gopath_relative = os.path.join(gopath, 'src', flag)
if os.path.isfile(gopath_relative):
found_filename = True
flag = gopath_relative
use_new_flags = True
break
new_flags.append(flag)
if use_new_flags:
flags = new_flags
if not found_filename:
flags.append(self.window.active_view().file_name())
if task == 'cross_compile':
_task_cross_compile(
self,
go_bin,
flags,
working_dir,
env
)
return
if task == 'benchmark':
# Switch back to the real Go command-line arg
task = 'test'
# Allow user to set a regexp for the benchmarks to run
found_bench_flag = False
# Need to match '-bench=xyz', ['-bench','xyz'], ['-bench','.']
# Don't match '-benchmem' or '-benchtime'
# Remember user can't specify spaces in flags
for flag in flags:
if flag == '-bench' or flag.startswith('-bench='):
found_bench_flag = True
# Otherwise default to running all benchmarks
if not found_bench_flag:
flags.append('-bench=.')
args = [go_bin, task]
if flags and isinstance(flags, list):
args.extend(flags)
proc = _run_process(
task,
self.window,
args,
working_dir,
env
)
_set_proc(self.window, proc)
def do_test():
golangconfig.setting_value(b'GOPATH', mock_context.view,
mock_context.window)
def do_test():
golangconfig.setting_value('GOPATH', True, mock_context.window)
def on_pre_save(self, view):
if not GoBuffers.is_go_source(view): return
if not golangconfig.setting_value("format_on_save")[0]: return
view.run_command('gotools_format')
def do_test():
golangconfig.setting_value('GOPATH', True, mock_context.window)
def do_test():
golangconfig.setting_value('GOPATH', mock_context.view, True)
def do_test():
golangconfig.setting_value(b'GOPATH', mock_context.view, mock_context.window)
def do_test():
golangconfig.setting_value(CustomString('GOPATH'), mock_context.view, mock_context.window)
def setting_value_gopath(self, shell, env, view_settings, window_settings, sublime_settings, setting, result):
with GolangConfigMock(shell, env, view_settings, window_settings, sublime_settings) as mock_context:
self.assertEquals(result, golangconfig.setting_value(setting, mock_context.view, mock_context.window))
self.assertEqual('', sys.stdout.getvalue())
def run(self, task="build", flags=None):
"""
Runs the "golang_build" command - invoked by Sublime Text via the
command palette or sublime.Window.run_command()
:param task:
A unicode string of "build", "test", "install", "clean"
or "cross_compile"
:param flags:
A list of unicode strings of flags to send to the command-line go
tool. The "cross_compile" task executes the "build" command with
the GOOS and GOARCH environment variables set, meaning that
flags for "build" should be used with it. Execute "go help" on the
command line to learn about available flags.
"""
if _yield_to_running_build(self.window):
return
working_dir = _determine_working_dir(self.window)
if working_dir is None:
return
go_bin, env = _get_config(
"go", set(["GOPATH"]), GO_ENV_VARS - set(["GOPATH"]), view=self.window.active_view(), window=self.window
)
if (go_bin, env) == (None, None):
return
if flags is None:
flags, _ = golangconfig.setting_value("%s:flags" % task, view=self.window.active_view(), window=self.window)
if flags is None:
flags = ["-v"]
if task == "run":
# Allow the user to set a file path into the flags settings,
# thus requiring that the flags be checked to ensure a second
# filename is not added
found_filename = False
# Allow users to call "run" with a src-relative file path. Because
# of that, flags may be rewritten since the "go run" does not
# accept such file paths.
use_new_flags = False
new_flags = []
gopaths = env["GOPATH"].split(os.pathsep)
for flag in flags:
if flag.endswith(".go"):
absolute_path = flag
if os.path.isfile(absolute_path):
found_filename = True
break
# If the file path is src-relative, rewrite the flag
for gopath in gopaths:
gopath_relative = os.path.join(gopath, "src", flag)
if os.path.isfile(gopath_relative):
found_filename = True
flag = gopath_relative
use_new_flags = True
break
new_flags.append(flag)
if use_new_flags:
flags = new_flags
if not found_filename:
flags.append(self.window.active_view().file_name())
if task == "cross_compile":
_task_cross_compile(self, go_bin, flags, working_dir, env)
return
args = [go_bin, task]
if flags and isinstance(flags, list):
args.extend(flags)
proc = _run_process(task, self.window, args, working_dir, env)
_set_proc(self.window, proc)
def log(msg):
if golangconfig.setting_value('debug_enabled')[0]:
print("GoTools: DEBUG: {0}".format(msg))
def on_post_save(self, view):
if not GoBuffers.is_go_source(view): return
if not golangconfig.setting_value("lint_on_save")[0]: return
view.run_command('gotools_lint')
def do_test():
golangconfig.setting_value(CustomString('GOPATH'),
mock_context.view,
mock_context.window)
def on_post_save(self, view):
if not GoBuffers.is_go_source(view): return
if not golangconfig.setting_value("lint_on_save")[0]: return
if Logger.err: return
view.run_command('gotools_lint')
def do_test():
golangconfig.setting_value('GOPATH', mock_context.view, True)
