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 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 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 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): 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 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 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 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()