def on_margo_done(c):
s = '\n'.join(c.consume_outq())
x = c.exception()
if x:
gs.notice(DOMAIN, 'MarGo Error: %s\nOutput: %s' % (x, s))
else:
gs.println('%s: MarGo: %s' % (DOMAIN, s))
def f(res, err):
if err:
gs.notice(DOMAIN, err)
return
decls = res.get('file_decls', [])
for d in res.get('pkg_decls', []):
if not vfn or d['fn'] != vfn:
decls.append(d)
for d in decls:
dname = (d['repr'] or d['name'])
trailer = []
trailer.extend(GOOS_PAT.findall(d['fn']))
trailer.extend(GOARCH_PAT.findall(d['fn']))
if trailer:
trailer = ' (%s)' % ', '.join(trailer)
else:
trailer = ''
d['ent'] = '%s %s%s' % (d['kind'], dname, trailer)
ents = []
decls.sort(key=lambda d: d['ent'])
for d in decls:
ents.append(d['ent'])
def cb(i):
if i >= 0:
d = decls[i]
gs.focus(d['fn'], d['row'], d['col'], win)
if ents:
win.show_quick_panel(ents, cb)
else:
win.show_quick_panel([['', 'No declarations found']], lambda x: None)
def complete(self, fn, offset, src, func_name_only):
comps = []
autocomplete_tests = gs.setting("autocomplete_tests", False)
autocomplete_closures = gs.setting("autocomplete_closures", False)
ents, err = mg9.complete(fn, src, offset)
if err:
gs.notice(DOMAIN, err)
name_fx = None
name_fx_pat = gs.setting("autocomplete_filter_name")
if name_fx_pat:
try:
name_fx = re.compile(name_fx_pat)
except Exception as ex:
gs.notice(DOMAIN, "Cannot filter completions: %s" % ex)
for ent in ents:
if name_fx and name_fx.search(ent["name"]):
continue
tn = ent["type"]
cn = ent["class"]
nm = ent["name"]
is_func = cn == "func"
is_func_type = cn == "type" and tn.startswith("func(")
if is_func:
if nm in ("main", "init"):
continue
if not autocomplete_tests and nm.startswith(("Test", "Benchmark", "Example")):
continue
if is_func or is_func_type:
s_sfx = u"\u0282"
t_sfx = gs.CLASS_PREFIXES.get("type", "")
f_sfx = gs.CLASS_PREFIXES.get("func", "")
params, ret = declex(tn)
decl = []
for i, p in enumerate(params):
n, t = p
if t.startswith("..."):
n = "..."
decl.append("${%d:%s}" % (i + 1, n))
decl = ", ".join(decl)
ret = ret.strip("() ")
if is_func:
if func_name_only:
comps.append(("%s\t%s %s" % (nm, ret, f_sfx), nm))
else:
comps.append(("%s\t%s %s" % (nm, ret, f_sfx), "%s(%s)" % (nm, decl)))
else:
comps.append(("%s\t%s %s" % (nm, tn, t_sfx), nm))
if autocomplete_closures:
comps.append(("%s {}\tfunc() {...} %s" % (nm, s_sfx), "%s {\n\t${0}\n}" % tn))
elif cn != "PANIC":
comps.append(("%s\t%s %s" % (nm, tn, self.typeclass_prefix(cn, tn)), nm))
return comps
def f(im, err):
if err:
gs.notice(DOMAIN, err)
return
delete_imports = []
add_imports = []
for path in im.get('paths', []):
skipAdd = False
for i in im.get('imports', []):
if i.get('path') == path:
skipAdd = True
name = i.get('name', '')
if not name:
name = basename(path)
if name == path:
delete_imports.append(('%sdelete: %s' % (indent, name), i))
else:
delete_imports.append(('%sdelete: %s ( %s )' % (indent, name, path), i))
if not skipAdd:
add_imports.append(('%s%s' % (indent, path), {'path': path, 'add': True}))
for i in sorted(delete_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
if len(delete_imports) > 0:
self.add_item(' ', self.show_palette, 'imports')
for i in sorted(add_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
self.do_show_panel()
def do_hello():
global hello_sarting
if hello_sarting:
return
hello_sarting = True
tid = gs.begin(DOMAIN, 'Starting Gocode', False)
call_cmd([mg9.GOCODE_BIN])
gs.end(tid)
margo_cmd = list(gs.setting('margo_cmd', []))
margo_cmd = [
mg9.MARGO0_BIN,
"-d",
"-call", "replace",
"-addr", gs.setting('margo_addr', '')
]
tid = gs.begin(DOMAIN, 'Starting MarGo', False)
out, err, _ = gs.runcmd(margo_cmd)
gs.end(tid)
out = out.strip()
err = err.strip()
if err:
gs.notice(DOMAIN, err)
elif out:
gs.println(DOMAIN, 'MarGo started %s' % out)
hello_sarting = False
def resolve_snippets(ctx):
cl = set()
types = [''] if ctx.get('local') else ctx.get('types')
vars = {}
for k,v in ctx.iteritems():
if gs.is_a_string(v):
vars[k] = v
try:
snips = []
snips.extend(gs.setting('default_snippets', []))
snips.extend(gs.setting('snippets', []))
for m in snips:
try:
if snippet_match(ctx, m):
for ent in m.get('snippets', []):
text = ent.get('text', '')
title = ent.get('title', '')
value = ent.get('value', '')
if text and value:
for typename in types:
vars['typename'] = typename
vars['typename_abbr'] = typename[0].lower() if typename else ''
txt, ttl, val = expand_snippet_vars(vars, text, title, value)
s = u'%s\t%s \u0282' % (txt, ttl)
cl.add((s, val))
except:
gs.notice(DOMAIN, gs.traceback())
except:
gs.notice(DOMAIN, gs.traceback())
return list(cl)
def run(self, edit):
if not gs.is_go_source_view(self.view):
return
region = sublime.Region(0, self.view.size())
src = self.view.substr(region)
args = [gs.setting("gofmt_cmd", "gofmt"), "-d"]
diff, err = gs.runcmd(args, src)
if err:
fn = self.view.file_name()
err = err.replace('<standard input>', fn)
gs.notice('GsFmt', 'File %s contains errors' % fn)
elif diff:
err = ''
try:
edit = self.view.begin_edit()
ed = SublimeEditor(self.view, edit)
err = thatcher.patch(ed, diff)
except Exception as e:
err = "%s\n\n%s" % (err, e)
finally:
self.view.end_edit(edit)
if err:
def cb():
if ed.dirty:
self.view.run_command('undo')
gs.notice("GsFmt", "Could not patch the buffer: %s" % err)
sublime.set_timeout(cb, 0)
def show_pkgfiles(dirname):
ents = []
m = {}
try:
dirname = os.path.abspath(dirname)
for fn in gs.list_dir_tree(dirname, ext_filter, gs.setting('fn_exclude_prefixes', [])):
name = os.path.relpath(fn, dirname).replace('\\', '/')
m[name] = fn
ents.append(name)
except Exception as ex:
gs.notice(DOMAIN, 'Error: %s' % ex)
if ents:
ents.sort(key = lambda a: a.lower())
try:
s = " ../ ( current: %s )" % dirname
m[s] = os.path.join(dirname, "..")
ents.insert(0, s)
except Exception:
pass
def cb(i, win):
if i >= 0:
fn = m[ents[i]]
if os.path.isdir(fn):
win.run_command("gs_browse_files", {"dir": fn})
else:
gs.focus(fn, 0, 0, win)
gs.show_quick_panel(ents, cb)
else:
gs.show_quick_panel([['', 'No files found']])
def toggle_import(self, a):
global last_import_path
view, decl = a
im, err = margo.imports(
view.file_name(),
view.substr(sublime.Region(0, view.size())),
False,
[decl]
)
if err:
gs.notice(DOMAIN, err)
else:
src = im.get('src', '')
size_ref = im.get('size_ref', 0)
if src and size_ref > 0:
dirty, err = gspatch.merge(view, size_ref, src)
if err:
gs.notice_undo(DOMAIN, err, view, dirty)
elif dirty:
if decl.get('add'):
last_import_path[view.file_name()] = decl.get('path')
else:
last_import_path[view.file_name()] = ''
gs.notice(DOMAIN, 'imports updated...')
def jump_to_imports(self):
view = gs.active_valid_go_view()
if not view:
return
last_import = last_import_path.get(view.file_name())
r = None
if last_import:
offset = len(last_import) + 2
last_import = re.escape(last_import)
pat = '(?s)import.*?(?:"%s"|`%s`)' % (last_import, last_import)
r = view.find(pat, 0)
if not r:
offset = 1
pat = '(?s)import.*?["`]'
r = view.find(pat, 0)
if not r:
gs.notice(DOMAIN, "cannot find import declarations")
return
pt = r.end() - offset
row, col = view.rowcol(pt)
loc = Loc(view.file_name(), row, col)
self.jump_to((view, loc))
def on_margo_done(c):
s = '\n'.join(c.consume_outq())
x = c.exception()
if x:
gs.notice(DOMAIN, 'MarGo Error: %s\nOutput: %s' % (x, s))
else:
gs.println('%s: MarGo: %s' % (DOMAIN, s))
def palette_imports(self, view, direct=False):
indent = '' if direct else ' '
im, err = margo.imports(
view.file_name(),
view.substr(sublime.Region(0, view.size())),
True,
[]
)
if err:
gs.notice(DOMAIN, err)
delete_imports = []
add_imports = []
imports = im.get('file_imports', [])
for path in im.get('import_paths', []):
skipAdd = False
for i in imports:
if i.get('path') == path:
skipAdd = True
name = i.get('name', '')
if not name:
name = basename(path)
if name == path:
delete_imports.append(('%sdelete: %s' % (indent, name), i))
else:
delete_imports.append(('%sdelete: %s ( %s )' % (indent, name, path), i))
if not skipAdd:
add_imports.append(('%s%s' % (indent, path), {'path': path, 'add': True}))
for i in sorted(delete_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
self.add_item(' --- ', self.show_palette, 'imports')
for i in sorted(add_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
def on_gocode_done(c): s = '\n'.join(c.consume_outq()) x = c.exception() if x: gs.notice(DOMAIN, 'Gocode Error: %s\nOutput: %s' % (x, s)) else: gsshell.Command(cmd=[BUNDLE_GOCODE], cwd=BUNDLE_GOBIN).start()
def print_install_log(c, s):
e = gs.env()
dur = c.ended - c.started
pkgdir = sublime.packages_path()
subl9_status = (BUNDLE_GOSUBLIME9.replace(pkgdir, 'Packages'), os.path.exists(BUNDLE_GOSUBLIME9))
margo_status = (BUNDLE_GOCODE.replace(pkgdir, 'Packages'), os.path.exists(BUNDLE_GOCODE))
gocode_status = (BUNDLE_MARGO.replace(pkgdir, 'Packages'), os.path.exists(BUNDLE_MARGO))
gs.println(
'GoSublime: %s done %0.3fs' % (DOMAIN, dur),
'| Bundle GOPATH: %s' % BUNDLE_GOPATH.replace(pkgdir, 'Packages'),
'| Bundle GOBIN: %s' % BUNDLE_GOBIN.replace(pkgdir, 'Packages'),
'| Bundle Gocode: %s (exists: %s)' % gocode_status,
'| Bundle GoSublime9: %s (exists: %s)' % subl9_status,
'| Bundle MarGo: %s (exists: %s)' % margo_status,
'| User GOROOT: %s' % e.get('GOROOT', '(NOT SET)'),
'| User GOPATH: %s' % e.get('GOPATH', '(NOT SET)'),
'| User GOBIN: %s (should usually be `NOT SET\')' % e.get('GOBIN', '(NOT SET)'),
s
)
CRITICAL_ENV_VARS = ('GOROOT', 'GOPATH')
unset_vars = [var for var in CRITICAL_ENV_VARS if not e.get(var)]
if unset_vars:
tpl = 'check the console for error messages: the following environment variables are not set: %s'
gs.notice(DOMAIN, tpl % ', '.join(unset_vars))
def f(): out, err, _ = gs.runcmd(['go', 'get', '-u', '-v', GOCODE_REPO, MARGO_REPO]) margo.bye_ni() call_cmd(['gocode', 'close']) gs.notice(DOMAIN, '%s done' % msg) gs.println(DOMAIN, '%s done\n%s%s' % (msg, out, err)) do_hello()
def f(res, err):
if err:
gs.notice(DOMAIN, err)
return
decls = res.get("file_decls", [])
for d in res.get("pkg_decls", []):
if not vfn or d["fn"] != vfn:
decls.append(d)
for d in decls:
dname = d["repr"] or d["name"]
trailer = []
trailer.extend(GOOS_PAT.findall(d["fn"]))
trailer.extend(GOARCH_PAT.findall(d["fn"]))
if trailer:
trailer = " (%s)" % ", ".join(trailer)
else:
trailer = ""
d["ent"] = "%s %s%s" % (d["kind"], dname, trailer)
ents = []
decls.sort(key=lambda d: d["ent"])
for d in decls:
ents.append(d["ent"])
def cb(i):
if i >= 0:
d = decls[i]
gs.focus(d["fn"], d["row"], d["col"], win)
if ents:
win.show_quick_panel(ents, cb)
else:
win.show_quick_panel([["", "No declarations found"]], lambda x: None)
def print_install_log(c, s):
e = gs.env()
dur = c.ended - c.started
pkgdir = sublime.packages_path()
subl9_status = (BUNDLE_GOSUBLIME9.replace(pkgdir, 'Packages'),
os.path.exists(BUNDLE_GOSUBLIME9))
margo_status = (BUNDLE_GOCODE.replace(pkgdir, 'Packages'),
os.path.exists(BUNDLE_GOCODE))
gocode_status = (BUNDLE_MARGO.replace(pkgdir, 'Packages'),
os.path.exists(BUNDLE_MARGO))
gs.println(
'GoSublime: %s done %0.3fs' % (DOMAIN, dur),
'| Bundle GOPATH: %s' % BUNDLE_GOPATH.replace(pkgdir, 'Packages'),
'| Bundle GOBIN: %s' % BUNDLE_GOBIN.replace(pkgdir, 'Packages'),
'| Bundle Gocode: %s (exists: %s)' % gocode_status,
'| Bundle GoSublime9: %s (exists: %s)' % subl9_status,
'| Bundle MarGo: %s (exists: %s)' % margo_status,
'| User GOROOT: %s' % e.get('GOROOT', '(NOT SET)'),
'| User GOPATH: %s' % e.get('GOPATH', '(NOT SET)'),
'| User GOBIN: %s (should usually be `NOT SET\')' %
e.get('GOBIN', '(NOT SET)'), s)
CRITICAL_ENV_VARS = ('GOROOT', 'GOPATH')
unset_vars = [var for var in CRITICAL_ENV_VARS if not e.get(var)]
if unset_vars:
tpl = 'check the console for error messages: the following environment variables are not set: %s'
gs.notice(DOMAIN, tpl % ', '.join(unset_vars))
def run(self):
self.started = time.time()
tid = gs.begin(DOMAIN,
self.message,
set_status=False,
cancel=self.cancel)
try:
try:
self.p = gs.popen(self.cmd,
shell=self.shell,
stderr=subprocess.STDOUT,
environ=self.env,
cwd=self.cwd,
bufsize=1)
CommandStdoutReader(self, self.p.stdout).start()
except Exception as ex:
self.x = ex
finally:
self.rcode = self.p.wait() if self.p else False
finally:
gs.end(tid)
self.ended = time.time()
self.on_done(self)
for f in self.done:
try:
f(self)
except Exception:
gs.notice(DOMAIN, gs.traceback())
def on_gocode_done(c):
s = '\n'.join(c.consume_outq())
x = c.exception()
if x:
gs.notice(DOMAIN, 'Gocode Error: %s\nOutput: %s' % (x, s))
else:
gsshell.Command(cmd=[BUNDLE_GOCODE], cwd=BUNDLE_GOBIN).start()
def toggle_import(self, a):
global last_import_path
view, decl = a
im, err = mg9.imports(
view.file_name(),
view.substr(sublime.Region(0, view.size())),
[decl]
)
if err:
gs.notice(DOMAIN, err)
else:
src = im.get('src', '')
line_ref = im.get('lineRef', 0)
r = view.full_line(view.text_point(max(0, line_ref-1), 0))
if not src or line_ref < 1 or not r:
return
dirty, err = gspatch.merge(view, r.end(), src)
if err:
gs.notice_undo(DOMAIN, err, view, dirty)
elif dirty:
if decl.get('add'):
last_import_path[view.file_name()] = decl.get('path')
else:
last_import_path[view.file_name()] = ''
def resolve_snippets(ctx):
cl = set()
types = [''] if ctx.get('local') else ctx.get('types')
vars = {}
for k, v in ctx.iteritems():
if gs.is_a_string(v):
vars[k] = v
try:
snips = []
snips.extend(gs.setting('default_snippets', []))
snips.extend(gs.setting('snippets', []))
for m in snips:
try:
if snippet_match(ctx, m):
for ent in m.get('snippets', []):
text = ent.get('text', '')
title = ent.get('title', '')
value = ent.get('value', '')
if text and value:
for typename in types:
vars['typename'] = typename
vars['typename_abbr'] = typename[0].lower(
) if typename else ''
txt, ttl, val = expand_snippet_vars(
vars, text, title, value)
s = u'%s\t%s \u0282' % (txt, ttl)
cl.add((s, val))
except:
gs.notice(DOMAIN, gs.traceback())
except:
gs.notice(DOMAIN, gs.traceback())
return list(cl)
def f(res, err):
if err:
gs.notice(DOMAIN, err)
return
decls = res.get('file_decls', [])
for d in res.get('pkg_decls', []):
if not vfn or d['fn'] != vfn:
decls.append(d)
for d in decls:
dname = (d['repr'] or d['name'])
trailer = []
trailer.extend(GOOS_PAT.findall(d['fn']))
trailer.extend(GOARCH_PAT.findall(d['fn']))
if trailer:
trailer = ' (%s)' % ', '.join(trailer)
else:
trailer = ''
d['ent'] = '%s %s%s' % (d['kind'], dname, trailer)
ents = []
decls.sort(key=lambda d: d['ent'])
for d in decls:
ents.append(d['ent'])
def cb(i):
if i >= 0:
d = decls[i]
gs.focus(d['fn'], d['row'], d['col'], win)
if ents:
win.show_quick_panel(ents, cb)
else:
win.show_quick_panel([['', 'No declarations found']], lambda x: None)
def jump_to_imports(self): view = gs.active_valid_go_view() if not view: return last_import = last_import_path.get(view.file_name()) r = None if last_import: offset = len(last_import) + 2 last_import = re.escape(last_import) pat = '(?s)import.*?(?:"%s"|`%s`)' % (last_import, last_import) r = view.find(pat, 0) if not r: offset = 1 pat = '(?s)import.*?["`]' r = view.find(pat, 0) if not r: gs.notice(DOMAIN, "cannot find import declarations") return pt = r.end() - offset row, col = view.rowcol(pt) loc = Loc(view.file_name(), row, col) self.jump_to((view, loc))
def toggle_import(self, a):
global last_import_path
view, decl = a
im, err = mg9.imports(view.file_name(),
view.substr(sublime.Region(0, view.size())),
[decl])
if err:
gs.notice(DOMAIN, err)
else:
src = im.get('src', '')
line_ref = im.get('lineRef', 0)
r = view.full_line(view.text_point(max(0, line_ref - 1), 0))
if not src or line_ref < 1 or not r:
return
dirty, err = gspatch.merge(view, r.end(), src)
if err:
gs.notice_undo(DOMAIN, err, view, dirty)
elif dirty:
if decl.get('add'):
last_import_path[view.file_name()] = decl.get('path')
else:
last_import_path[view.file_name()] = ''
def run(self):
tid = gs.begin(self.domain, self.msg, self.set_status)
try:
self.f()
except Exception:
gs.notice(self.domain, gs.traceback())
finally:
gs.end(tid)
def run(self):
view = gs.active_valid_go_view(self.window)
if not view:
gs.notice("GsShell", "this not a source.go view")
return
p = Prompt(view)
p.panel = self.window.show_input_panel("GsShell", "go ", p.on_done, p.on_change, None)
def run(self):
tid = gs.begin(self.domain, self.msg, self.set_status)
try:
self.f()
except Exception:
gs.notice(self.domain, gs.traceback())
finally:
gs.end(tid)
def run(self):
while not self.stop_ev.is_set():
try:
self.ready_ev.wait()
self.ready_ev.clear()
self.lint()
except Exception:
gs.notice("GsLintThread: Loop", traceback.format_exc())
def do_comp_lint(dirname, fn):
fr = ref(fn, False)
reports = {}
if not fr:
return
fn = gs.apath(fn, dirname)
bindir, _ = gs.temp_dir('bin')
local_env = {
'GOBIN': bindir,
}
pat = r'%s:(\d+)(?:[:](\d+))?\W+(.+)\s*' % re.escape(os.path.basename(fn))
pat = re.compile(pat, re.IGNORECASE)
for c in gs.setting('comp_lint_commands'):
try:
cmd = c.get('cmd')
if not cmd:
continue
cmd_domain = ' '.join(cmd)
shell = c.get('shell') is True
env = {} if c.get('global') is True else local_env
out, err, _ = gsshell.run(cmd=cmd,
shell=shell,
cwd=dirname,
env=env)
if err:
gs.notice(DOMAIN, err)
out = out.replace('\r',
'').replace('\n ',
'\\n ').replace('\n\t', '\\n\t')
for m in pat.findall(out):
try:
row, col, msg = m
row = int(row) - 1
col = int(col) - 1 if col else 0
msg = msg.replace('\\n', '\n').strip()
if row >= 0 and msg:
msg = '%s: %s' % (cmd_domain, msg)
if reports.get(row):
reports[row].msg = '%s\n%s' % (reports[row].msg,
msg)
reports[row].col = max(reports[row].col, col)
else:
reports[row] = Report(row, col, msg)
except:
pass
except:
gs.notice(DOMAIN, gs.traceback())
def cb():
fr.reports = reports
fr.state = 1
highlight(fr)
sublime.set_timeout(cb, 0)
def run(self):
while not self.stop_ev.is_set():
try:
self.ready_ev.wait()
self.ready_ev.clear()
self.lint()
except Exception:
gs.notice("GsLintThread: Loop", traceback.format_exc())
# updat the view so the error is displayed without needing to move the cursor
self.gslint.on_selection_modified(self.view)
def request(path, a={}):
try:
a = urllib.urlencode(a)
h = {'Content-type': 'application/x-www-form-urlencoded'}
conn = httplib.HTTPConnection(gs.setting('margo_addr'))
conn.request("POST", path, a, h)
resp = json.load(conn.getresponse())
return resp
except:
gs.notice("Margo", traceback.format_exc())
return {}
def show_palette(self, palette, direct=False):
view = gs.active_valid_go_view(self.window)
if not view:
return
palette = palette.lower().strip()
if palette == 'auto':
palette = self.last_activate_palette
elif palette == 'main':
palette = ''
pcb = None
if palette:
pcb = self.palettes.get(palette)
if pcb:
self.last_activate_palette = palette
else:
gs.notice(DOMAIN, 'Invalid palette `%s`' % palette)
palette = ''
if not direct and len(self.bookmarks) > 0:
loc = self.bookmarks[-1]
line = 'line %d' % (loc.row + 1)
if view.file_name() == loc.fn:
fn = ''
else:
fn = relpath(loc.fn, dirname(loc.fn))
if fn.startswith('..'):
fn = loc.fn
fn = '%s ' % fn
self.add_item(u'\u2190 Go Back (%s%s)' % (fn, line),
self.jump_back, None)
if not direct and palette:
self.add_item(u'@%s \u21B5' % palette.title(), self.show_palette,
'main')
li1 = len(self.items)
if pcb:
pcb(view, direct)
if not direct:
for k in sorted(self.palettes.keys()):
if k:
if k != palette:
ttl = '@' + k.title()
if k == 'errors':
fr = gslint.ref(view.file_name())
if not fr or len(fr.reports) == 0:
continue
ttl = '%s (%d)' % (ttl, len(fr.reports))
itm = ttl
self.add_item(itm, self.show_palette, k)
def run(self, prompt="go ", run="", fmt_save=True):
view = gs.active_valid_go_view(self.window)
if not view:
gs.notice(DOMAIN, "this not a source.go view")
return
run = run.strip()
p = Prompt(view, run == "")
if run:
p.on_done(run, fmt_save)
else:
p.panel = self.window.show_input_panel("GsShell", prompt, p.on_done, p.on_change, None)
def snippet_match(ctx, m):
try:
for k,p in m.get('match', {}).iteritems():
q = ctx.get(k, '')
if p and gs.is_a_string(p):
if not re.search(p, str(q)):
return False
elif p != q:
return False
except:
gs.notice(DOMAIN, gs.traceback())
return True
def run(self, prompt="go ", run=""):
view = gs.active_valid_go_view(self.window)
if not view:
gs.notice(DOMAIN, "this not a source.go view")
return
run = run.strip()
p = Prompt(view, run == "")
if run:
p.on_done(run)
else:
p.panel = self.window.show_input_panel("GsShell", prompt, p.on_done, p.on_change, None)
def _send():
while True:
try:
try:
method, arg, cb = _send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
if proc:
try:
proc.kill()
proc.stdout.close()
except:
pass
maybe_install()
if not gs.checked(DOMAIN, 'launch _recv'):
gsq.launch(DOMAIN, _recv)
proc, _, err = gsshell.proc([MARGO9_BIN, '-poll=30'],
stderr=gs.LOGFILE,
env={
'XDG_CONFIG_HOME':
gs.home_path(),
})
gs.set_attr(PROC_ATTR_NAME, proc)
if not proc:
gs.notice(DOMAIN, 'Cannot MarGo: %s' % err)
continue
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX + req.token, req)
gs.debug(
DOMAIN, 'margo request: method: %s, token: %s' %
(req.method, req.token))
header, _ = gs.json_encode({
'method': method,
'token': req.token
})
body, _ = gs.json_encode(arg)
ln = '%s %s\n' % (header, body)
proc.stdin.write(ln)
except Exception:
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def snippet_match(ctx, m):
try:
for k, p in m.get('match', {}).iteritems():
q = ctx.get(k, '')
if p and gs.is_a_string(p):
if not re.search(p, str(q)):
return False
elif p != q:
return False
except:
gs.notice(DOMAIN, gs.traceback())
return True
def on_output_done(self): ex = self.exception() if ex: self.on_output(self, 'Error: ' % ex) t = (max(0, self.ended - self.started), max(0, self.output_started - self.started)) self.do_insert(['[ elapsed: %0.3fs, startup: %0.3fs]\n' % t]) for f in self.output_done: try: f(self) except Exception: gs.notice(DOMAIN, gs.traceback())
def run(self, palette="main"):
if not hasattr(self, "items"):
self.items = []
self.bookmarks = []
palettes = {"main": self.act_show_main_palette, "declarations": self.act_list_declarations}
p = palettes.get(palette)
if p:
p()
else:
gs.notice("GsPalette", "Invalid palette `%s`" % palette)
palettes["main"]()
def do_comp_lint(dirname, fn):
fr = ref(fn, False)
reports = {}
if not fr:
return
fn = gs.apath(fn, dirname)
bindir, _ = gs.temp_dir('bin')
local_env = {
'GOBIN': bindir,
}
pat = r'%s:(\d+)(?:[:](\d+))?\W+(.+)\s*' % re.escape(os.path.basename(fn))
pat = re.compile(pat, re.IGNORECASE)
for c in gs.setting('comp_lint_commands'):
try:
cmd = c.get('cmd')
if not cmd:
continue
cmd_domain = ' '.join(cmd)
shell = c.get('shell') is True
env = {} if c.get('global') is True else local_env
out, err, _ = gsshell.run(cmd=cmd, shell=shell, cwd=dirname, env=env)
if err:
gs.notice(DOMAIN, err)
out = out.replace('\r', '').replace('\n ', '\\n ').replace('\n\t', '\\n\t')
for m in pat.findall(out):
try:
row, col, msg = m
row = int(row)-1
col = int(col)-1 if col else 0
msg = msg.replace('\\n', '\n').strip()
if row >= 0 and msg:
msg = '%s: %s' % (cmd_domain, msg)
if reports.get(row):
reports[row].msg = '%s\n%s' % (reports[row].msg, msg)
reports[row].col = max(reports[row].col, col)
else:
reports[row] = Report(row, col, msg)
except:
pass
except:
gs.notice(DOMAIN, gs.traceback())
def cb():
fr.reports = reports
fr.state = 1
highlight(fr)
sublime.set_timeout(cb, 0)
def run(self):
win, view = gs.win_view(None, self.window)
if view is None:
return
mats = {}
args = {}
vfn = gs.view_fn(view)
src = gs.view_src(view)
pkg_dir = ''
if view.file_name():
pkg_dir = os.path.dirname(view.file_name())
res, err = margo.declarations(vfn, src, pkg_dir)
if err:
gs.notice(DOMAIN, err)
return
decls = res.get('file_decls', [])
decls.extend(res.get('pkg_decls', []))
for d in decls:
name = d['name']
m = TEST_PAT.match(name)
if m and d['kind'] == 'func' and d['repr'] == '':
mats[m.group(1)] = True
args[name] = name
names = sorted(args.keys())
ents = ['Run all tests and examples']
for k in ['Test', 'Benchmark', 'Example']:
if mats.get(k):
s = 'Run %ss Only' % k
ents.append(s)
if k == 'Benchmark':
args[s] = '-test.run=none -test.bench=%s.*' % k
else:
args[s] = '-test.run=%s.*' % k
for k in names:
ents.append(k)
if k.startswith('Benchmark'):
args[k] = '-test.run=none -test.bench=^%s$' % k
else:
args[k] = '-test.run=^%s$' % k
def cb(i):
if i >= 0:
s = 'go test %s' % args.get(ents[i], '')
win.run_command('gs_shell', {'run': s})
win.show_quick_panel(ents, cb)
def show_palette(self, palette, direct=False):
view = gs.active_valid_go_view(self.window)
if not view:
return
palette = palette.lower().strip()
if palette == 'auto':
palette = self.last_activate_palette
elif palette == 'main':
palette = ''
pcb = None
if palette:
pcb = self.palettes.get(palette)
if pcb:
self.last_activate_palette = palette
else:
gs.notice(DOMAIN, 'Invalid palette `%s`' % palette)
palette = ''
if not direct and len(self.bookmarks) > 0:
loc = self.bookmarks[-1]
line = 'line %d' % (loc.row + 1)
if view.file_name() == loc.fn:
fn = ''
else:
fn = relpath(loc.fn, dirname(loc.fn))
if fn.startswith('..'):
fn = loc.fn
fn = '%s ' % fn
self.add_item(u'\u2190 Go Back (%s%s)' % (fn, line), self.jump_back, None)
if not direct and palette:
self.add_item(u'@%s \u21B5' % palette.title(), self.show_palette, 'main')
li1 = len(self.items)
if pcb:
pcb(view, direct)
if not direct:
for k in sorted(self.palettes.keys()):
if k:
if k != palette:
ttl = '@' + k.title()
if k == 'errors':
fr = gslint.ref(view.file_name())
if not fr or len(fr.reports) == 0:
continue
ttl = '%s (%d)' % (ttl, len(fr.reports))
itm = ttl
self.add_item(itm, self.show_palette, k)
def run(self):
win, view = gs.win_view(None, self.window)
if view is None:
return
mats = {}
args = {}
vfn = gs.view_fn(view)
src = gs.view_src(view)
pkg_dir = ''
if view.file_name():
pkg_dir = os.path.dirname(view.file_name())
res, err = margo.declarations(vfn, src, pkg_dir)
if err:
gs.notice(DOMAIN, err)
return
decls = res.get('file_decls', [])
decls.extend(res.get('pkg_decls', []))
for d in decls:
name = d['name']
prefix, _ = match_prefix_name(name)
if prefix and d['kind'] == 'func' and d['repr'] == '':
mats[True] = prefix
args[name] = name
names = sorted(args.keys())
ents = ['Run all tests and examples']
for k in ['Test', 'Benchmark', 'Example']:
if mats.get(k):
s = 'Run %ss Only' % k
ents.append(s)
if k == 'Benchmark':
args[s] = '-test.run=none -test.bench=%s.*' % k
else:
args[s] = '-test.run=%s.*' % k
for k in names:
ents.append(k)
if k.startswith('Benchmark'):
args[k] = '-test.run=none -test.bench=^%s$' % k
else:
args[k] = '-test.run=^%s$' % k
def cb(i):
if i >= 0:
s = 'go test %s' % args.get(ents[i], '')
win.run_command('gs_shell', {'run': s})
win.show_quick_panel(ents, cb)
def on_output_done(self):
ex = self.exception()
if ex:
self.on_output(self, 'Error: ' % ex)
t = (max(0, self.ended - self.started),
max(0, self.output_started - self.started))
self.do_insert(['[ elapsed: %0.3fs, startup: %0.3fs]\n' % t])
for f in self.output_done:
try:
f(self)
except Exception:
gs.notice(DOMAIN, gs.traceback())
def run(self):
while True:
try:
f, msg = self.q.get()
tid = gs.begin(self.domain, msg, False)
try:
f()
except Exception:
gs.notice(self.domain, traceback.format_exc())
except:
pass
gs.end(tid)
def f(res, err):
if err:
gs.notice(DOMAIN, err)
return
ents, m = handle_pkgdirs_res(res)
if ents:
def cb(i, win):
if i >= 0:
dirname = gs.basedir_or_cwd(m[ents[i]])
win.run_command('gs_browse_files', {'dir': dirname})
gs.show_quick_panel(ents, cb)
else:
gs.show_quick_panel([['', 'No source directories found']])
def run(self):
while True:
try:
f, msg, set_status = self.q.get()
tid = gs.begin(self.domain, msg, set_status)
try:
f()
except Exception:
gs.notice(self.domain, gs.traceback())
except:
pass
gs.end(tid)
def run(self):
while True:
try:
f, msg, set_status = self.q.get()
tid = gs.begin(self.domain, msg, set_status)
try:
f()
except Exception:
gs.notice(self.domain, gs.traceback())
except:
pass
gs.end(tid)
def do_post_save(view):
if not gs.is_pkg_view(view):
return
for c in gs.setting('on_save', []):
cmd = c.get('cmd', '')
args = c.get('args', {})
msg = 'running on_save command %s' % cmd
tid = gs.begin(DOMAIN, msg, set_status=False)
try:
view.run_command(cmd, args)
except Exception as ex:
gs.notice(DOMAIN, 'Error %s' % ex)
finally:
gs.end(tid)
def do_post_save(view):
if not gs.is_pkg_view(view):
return
domain = 'GoSublime-On-Save'
for c in gs.setting('on_save', []):
cmd = c.get('cmd', '')
args = c.get('args', {})
msg = 'running on_save command %s' % cmd
tid = gs.begin(domain, msg, set_status=False)
gs.println(msg)
try:
view.run_command(cmd, args)
except Exception as ex:
gs.notice(domain, 'Error %s' % ex)
finally:
gs.end(tid)
def f(res, err):
if err:
gs.notice('GsDeclarations', err)
else:
decls = res.get('file_decls', [])
decls.sort(key=lambda v: v.get('row', 0))
added = 0
for i, v in enumerate(decls):
loc = Loc(v['fn'], v['row'], v['col'])
s = '%s %s' % (v['kind'], (v['repr'] or v['name']))
self.add_item(s, self.jump_to, (view, loc))
added += 1
if added < 1:
self.add_item(['', 'No declarations found'])
self.do_show_panel()
def f(res, err):
if err:
gs.notice(DOMAIN, err)
return
ents, m = handle_pkgdirs_res(res)
if ents:
ents.insert(0, "Current Package")
def cb(i, win):
if i == 0:
self.present_current()
elif i >= 1:
self.present('', '', os.path.dirname(m[ents[i]]))
gs.show_quick_panel(ents, cb)
else:
gs.show_quick_panel([['', 'No source directories found']])
def check_depends():
changelog_fn = gs.dist_path("CHANGELOG.md")
try:
with open(changelog_fn) as f:
s = f.read()
except IOError:
gs.notice(DOMAIN, traceback.format_exc())
return
changes = split_changes(s)
if changes:
def cb():
aso = gs.aso()
old_rev = aso.get('changelog.rev', '')
new_rev = changes[0][0]
if new_rev > old_rev:
aso.set('changelog.rev', new_rev)
gs.save_aso()
new_changes = [
'GoSublime: Recent Updates (you may need to restart Sublime Text for changes to take effect)',
'------------------------------------------------------------------------------------------',
]
for change in changes:
rev, msg = change
if rev > old_rev:
new_changes.append('\n%s\n\t%s' % (rev, msg))
else:
break
new_changes.append('\nSee %s for the full CHANGELOG\n' % changelog_fn)
new_changes = '\n'.join(new_changes)
gs.show_output(DOMAIN, new_changes, print_output=False)
sublime.set_timeout(cb, 0)
else:
margo.call(
path='/',
args='hello',
message='hello MarGo'
)
def run(self, edit):
vsize = self.view.size()
src = self.view.substr(sublime.Region(0, vsize))
if not src.strip():
return
src, err = margo.fmt(self.view.file_name(), src)
if err:
gs.notice(DOMAIN, "cannot fmt file. error: `%s'" % err)
return
if not src.strip():
gs.notice(DOMAIN,
"cannot fmt file. it appears to contain syntax errors")
return
_, err = gspatch.merge(self.view, vsize, src)
if err:
msg = 'PANIC: Cannot fmt file. Check your source for errors (and maybe undo any changes).'
sublime.error_message("%s: %s: Merge failure: `%s'" %
(DOMAIN, msg, err))
def run(self, edit):
v = self.view
pos = v.sel()[0].begin()
inscope = lambda p: v.score_selector(p, 'path.gscommander') > 0
if not inscope(pos):
pos -= 1
if not inscope(pos):
return
path = v.substr(v.extract_scope(pos))
if URL_PATH_PAT.match(path):
try:
if not URL_SCHEME_PAT.match(path):
path = 'http://%s' % path
gs.notice(DOMAIN, 'open url: %s' % path)
webbrowser.open_new_tab(path)
except Exception:
gs.notice(DOMAIN, gs.traceback())
else:
wd = v.settings().get('gscommander.wd') or active_wd()
m = SPLIT_FN_POS_PAT.match(path)
path = gs.apath((m.group(1) if m else path), wd)
row = max(0, int(m.group(2)) - 1 if (m and m.group(2)) else 0)
col = max(0, int(m.group(3)) - 1 if (m and m.group(3)) else 0)
if os.path.exists(path):
gs.focus(path, row, col, win=self.view.window())
else:
gs.notice(DOMAIN, "Invalid path `%s'" % path)
def complete(self, fn, offset, src, func_name_only):
global last_gopath
gopath = gs.env().get('GOPATH')
if gopath and gopath != last_gopath:
out, _, _ = gsshell.run(cmd=['go', 'env', 'GOOS', 'GOARCH'])
vars = out.strip().split()
if len(vars) == 2:
last_gopath = gopath
libpath = os.path.join(gopath, 'pkg', '_'.join(vars))
gsshell.run(cmd=['gocode', 'set', 'lib-path', libpath],
cwd=gsbundle.BUNDLE_GOBIN)
comps = []
cmd = gs.setting('gocode_cmd', 'gocode')
offset = 'c%s' % offset
args = [cmd, "-f=json", "autocomplete", fn, offset]
js, err, _ = gsshell.run(cmd=args, input=src)
if err:
gs.notice(DOMAIN, err)
else:
try:
js = json.loads(js)
if js and js[1]:
for ent in js[1]:
tn = ent['type']
cn = ent['class']
nm = ent['name']
sfx = self.typeclass_prefix(cn, tn)
if cn == 'func':
if nm in ('main', 'init'):
continue
act = gs.setting('autocomplete_tests', False)
if not act and nm.startswith(
('Test', 'Benchmark', 'Example')):
continue
params, ret = declex(tn)
ret = ret.strip('() ')
if func_name_only:
a = nm
else:
a = []
for i, p in enumerate(params):
n, t = p
if t.startswith('...'):
n = '...'
a.append('${%d:%s}' % (i + 1, n))
a = '%s(%s)' % (nm, ', '.join(a))
comps.append(('%s\t%s %s' % (nm, ret, sfx), a))
elif cn != 'PANIC':
comps.append(('%s\t%s %s' % (nm, tn, sfx), nm))
except KeyError as e:
gs.notice(
DOMAIN,
'Error while running gocode, possibly malformed data returned: %s'
% e)
except ValueError as e:
gs.notice(DOMAIN, "Error while decoding gocode output: %s" % e)
return comps
def do_hello():
global hello_sarting
if hello_sarting:
return
hello_sarting = True
margo_cmd = [
mg9.MARGO0_BIN, "-d", "-call", "replace", "-addr",
gs.setting('margo_addr', '')
]
tid = gs.begin(DOMAIN, 'Starting MarGo', False)
out, err, _ = gsshell.run(margo_cmd)
gs.end(tid)
out = out.strip()
err = err.strip()
if err:
gs.notice(DOMAIN, err)
elif out:
gs.println(DOMAIN, 'MarGo started %s' % out)
hello_sarting = False
def f(im, err):
if err:
gs.notice(DOMAIN, err)
return
delete_imports = []
add_imports = []
for path in im.get('paths', []):
skipAdd = False
for i in im.get('imports', []):
if i.get('path') == path:
skipAdd = True
name = i.get('name', '')
if not name:
name = basename(path)
if name == path:
delete_imports.append(
('%sdelete: %s' % (indent, name), i))
else:
delete_imports.append(
('%sdelete: %s ( %s )' % (indent, name, path),
i))
if not skipAdd:
add_imports.append(('%s%s' % (indent, path), {
'path': path,
'add': True
}))
for i in sorted(delete_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
if len(delete_imports) > 0:
self.add_item(' ', self.show_palette, 'imports')
for i in sorted(add_imports):
self.add_item(i[0], self.toggle_import, (view, i[1]))
self.do_show_panel()
