Example #1
0
def sanity_check(env={}, error_log=False):
	if not env:
		env = sh.env()

	ns = '(not set)'

	sl = [
		('install state', _inst_state()),
		('sublime.version', sublime.version()),
		('sublime.channel', sublime.channel()),
		('about.ann', gs.attr('about.ann', '')),
		('about.version', gs.attr('about.version', '')),
		('version', about.VERSION),
		('platform', about.PLATFORM),
		('~bin', '%s' % gs.home_dir_path('bin')),
		('margo.exe', '%s (%s)' % _tp(_margo_bin())),
		('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')),
		('go.version', sh.GO_VERSION),
		('GOROOT', '%s' % env.get('GOROOT', ns)),
		('GOPATH', '%s' % env.get('GOPATH', ns)),
		('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
		('set.shell', str(gs.lst(gs.setting('shell')))),
		('env.shell', env.get('SHELL', '')),
		('shell.cmd', str(sh.cmd('${CMD}'))),
	]

	if error_log:
		try:
			with open(gs.home_path('log.txt'), 'r') as f:
				s = f.read().strip()
				sl.append(('error log', s))
		except Exception:
			pass

	return sl
Example #2
0
def _install(maybe=False):
	if _inst_state() != "":
		return

	start = time.time()

	gs.set_attr(_inst_name(), 'busy')
	m_out = build_mg()
	gs.set_attr(_inst_name(), 'done')

	if m_out == 'ok':
		ev.margo_ready()
		gs.notify('GoSublime', 'ready')

		if maybe:
			return

	e = sh.env()
	a = [
		'GoSublime init %s (%0.3fs)' % (INSTALL_VERSION, time.time() - start),
	]

	sl = [('install margo', m_out)]
	sl.extend(sanity_check(e))
	a.extend(sanity_check_sl(sl))
	gs.println(*a)

	_check_env(e)
	killSrv()
	_cleanup()
Example #3
0
def sanity_check(env={}, error_log=False):
    if not env:
        env = sh.env()

    ns = "(not set)"

    sl = [
        ("install state", _inst_state()),
        ("sublime.version", sublime.version()),
        ("sublime.channel", sublime.channel()),
        ("about.ann", gs.attr("about.ann", "")),
        ("about.version", gs.attr("about.version", "")),
        ("version", about.VERSION),
        ("platform", about.PLATFORM),
        ("~bin", "%s" % gs.home_dir_path("bin")),
        ("margo.exe", "%s (%s)" % _tp(_margo_bin())),
        ("go.exe", "%s (%s)" % _tp(sh.which("go") or "go")),
        ("go.version", sh.GO_VERSION),
        ("GOROOT", "%s" % env.get("GOROOT", ns)),
        ("GOPATH", "%s" % env.get("GOPATH", ns)),
        ("GOBIN", "%s (should usually be `%s`)" % (env.get("GOBIN", ns), ns)),
        ("set.shell", str(gs.lst(gs.setting("shell")))),
        ("env.shell", env.get("SHELL", "")),
        ("shell.cmd", str(sh.cmd("${CMD}"))),
    ]

    if error_log:
        try:
            with open(gs.home_path("log.txt"), "r") as f:
                s = f.read().strip()
                sl.append(("error log", s))
        except Exception:
            pass

    return sl
Example #4
0
def fmt(fn, src):
    fn = fn or ''
    src = src or ''
    fmt_cmd = gs.settings_dict().get('fmt_cmd')
    if not fmt_cmd:
        return _mg_fmt(fn, src)

    env = sh.env()
    fmt_cmd = [string.Template(s).safe_substitute(env) for s in fmt_cmd]
    cmd_name = fmt_cmd[0]
    cmd_args = fmt_cmd[1:]
    res, err = bcall('sh', {
        'Env': env,
        'Cmd': {
            'Name': cmd_name,
            'Args': cmd_args,
            'Input': src,
        },
    },
                     err_title=cmd_name)
    err = err or res.get('err') or ''
    cmd_src = '' if err else (res.get('out') or '')
    if err:
        mg_src, mg_err = _mg_fmt(fn, src)
        if mg_src and not mg_err:
            err = 'Used MarGo fmt because %s failed:\n\n%s' % (cmd_name, err)
            cmd_src = mg_src

    return cmd_src, err
Example #5
0
def cmd_9(view, edit, args, wd, rkey):
    if len(args) == 0 or args[0] not in ('run', 'replay', 'build'):
        push_output(view, rkey, ('9: invalid args %s' % args))
        return

    subcmd = args[0]
    cid = ''
    if subcmd == 'replay':
        cid = '9replay-%s' % wd
    cid, cb = _9_begin_call(subcmd, view, edit, args, wd, rkey, cid)

    a = {
        'cid': cid,
        'env': sh.env(),
        'dir': wd,
        'args': args[1:],
        'build_only': (subcmd == 'build'),
    }

    win = view.window()
    if win is not None:
        av = win.active_view()
        if av is not None:
            fn = av.file_name()
            if fn:
                _save_all(win, wd)
            else:
                if gs.is_go_source_view(av, False):
                    a['fn'] = gs.view_fn(av)
                    a['src'] = av.substr(sublime.Region(0, av.size()))

    sublime.set_timeout(lambda: mg9.acall('play', a, cb), 0)
Example #6
0
def cmd_9(view, edit, args, wd, rkey):
    if len(args) == 0 or args[0] not in ("run", "replay", "build"):
        push_output(view, rkey, ("9: invalid args %s" % args))
        return

    subcmd = args[0]
    cid = ""
    if subcmd == "replay":
        cid = "9replay-%s" % wd
    cid, cb = _9_begin_call(subcmd, view, edit, args, wd, rkey, cid)

    a = {"cid": cid, "env": sh.env(), "dir": wd, "args": args[1:], "build_only": (subcmd == "build")}

    win = view.window()
    if win is not None:
        av = win.active_view()
        if av is not None:
            fn = av.file_name()
            if fn:
                _save_all(win, wd)
            else:
                if gs.is_go_source_view(av, False):
                    a["fn"] = gs.view_fn(av)
                    a["src"] = av.substr(sublime.Region(0, av.size()))

    sublime.set_timeout(lambda: mg9.acall("play", a, cb), 0)
Example #7
0
def fmt(fn, src):
	fn = fn or ''
	src = src or ''
	fmt_cmd = gs.settings_dict().get('fmt_cmd')
	if not fmt_cmd:
		return _mg_fmt(fn, src)

	env = sh.env()
	fmt_cmd = [string.Template(s).safe_substitute(env) for s in fmt_cmd]
	cmd_name = fmt_cmd[0]
	cmd_args = fmt_cmd[1:]
	res, err = bcall('sh', {
		'Env': env,
		'Cmd': {
			'Name': cmd_name,
			'Args': cmd_args,
			'Input': src,
		},
	}, err_title=cmd_name)
	err = err or res.get('err') or ''
	cmd_src = '' if err else (res.get('out') or '')
	if err:
		mg_src, mg_err = _mg_fmt(fn, src)
		if mg_src and not mg_err:
			err = 'Used MarGo fmt because %s failed:\n\n%s' % (cmd_name, err)
			cmd_src = mg_src

	return cmd_src, err
Example #8
0
def sanity_check(env={}, error_log=False):
	if not env:
		env = sh.env()

	ns = '(not set)'

	sl = [
		('install state', _inst_state()),
		('sublime.version', sublime.version()),
		('sublime.channel', sublime.channel()),
		('about.ann', gs.attr('about.ann', '')),
		('about.version', gs.attr('about.version', '')),
		('version', about.VERSION),
		('platform', about.PLATFORM),
		('~bin', '%s' % gs.home_dir_path('bin')),
		('margo.exe', '%s (%s)' % _tp(_margo_bin())),
		('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')),
		('go.version', sh.GO_VERSION),
		('GOROOT', '%s' % env.get('GOROOT', ns)),
		('GOPATH', '%s' % env.get('GOPATH', ns)),
		('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
		('set.shell', str(gs.lst(gs.setting('shell')))),
		('env.shell', env.get('SHELL', '')),
		('shell.cmd', str(sh.cmd('${CMD}'))),
	]

	if error_log:
		try:
			with open(gs.home_path('log.txt'), 'r') as f:
				s = f.read().strip()
				sl.append(('error log', s))
		except Exception:
			pass

	return sl
Example #9
0
def cmd_9(view, edit, args, wd, rkey):
	if len(args) == 0 or args[0] not in ('run', 'replay', 'build'):
		push_output(view, rkey, ('9: invalid args %s' % args))
		return

	subcmd = args[0]
	cid = ''
	if subcmd == 'replay':
		cid = '9replay-%s' % wd
	cid, cb = _9_begin_call(subcmd, view, edit, args, wd, rkey, cid)

	a = {
		'cid': cid,
		'env': sh.env(),
		'dir': wd,
		'args': args[1:],
		'build_only': (subcmd == 'build'),
	}

	win = view.window()
	if win is not None:
		av = win.active_view()
		if av is not None:
			fn = av.file_name()
			if fn:
				_save_all(win, wd)
			else:
				if gs.is_go_source_view(av, False):
					a['fn'] = gs.view_fn(av)
					a['src'] = av.substr(sublime.Region(0, av.size()))

	sublime.set_timeout(lambda: mg9.acall('play', a, cb), 0)
Example #10
0
def fmt(fn, src):
    st = gs.settings_dict()
    x = st.get('fmt_cmd')
    if x:
        env = sh.env()
        x = [string.Template(s).safe_substitute(env) for s in x]
        res, err = bcall(
            'sh', {
                'Env': env,
                'Cmd': {
                    'Name': x[0],
                    'Args': x[1:],
                    'Input': src or '',
                },
            })
        return res.get('out', ''), (err or res.get('err', ''))

    res, err = bcall(
        'fmt', {
            'Fn': fn or '',
            'Src': src or '',
            'TabIndent': st.get('fmt_tab_indent'),
            'TabWidth': st.get('fmt_tab_width'),
        })
    return res.get('src', ''), err
Example #11
0
def pkg_dirs(f):
    tid = gs.begin(DOMAIN, "Fetching pkg dirs")

    def cb(res, err):
        gs.end(tid)
        f(res, err)

    acall("pkg_dirs", {"env": sh.env()}, cb)
Example #12
0
def declarations(fn, src, pkg_dir, f):
    tid = gs.begin(DOMAIN, "Fetching declarations")

    def cb(res, err):
        gs.end(tid)
        f(res, err)

    return acall("declarations", {"fn": fn or "", "src": src, "env": sh.env(), "pkgDir": pkg_dir}, cb)
Example #13
0
def import_paths(fn, src, f):
    tid = gs.begin(DOMAIN, "Fetching import paths")

    def cb(res, err):
        gs.end(tid)
        f(res, err)

    acall("import_paths", {"fn": fn or "", "src": src or "", "env": sh.env()}, cb)
Example #14
0
def pkg_dirs(f):
	tid = gs.begin(DOMAIN, 'Fetching pkg dirs')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('pkg_dirs', {
		'env': sh.env(),
	}, cb)
Example #15
0
def cmd_sh(view, edit, args, wd, rkey):
    cid, cb = _9_begin_call("sh", view, edit, args, wd, rkey, "")
    a = {
        "cid": cid,
        "env": sh.env(),
        "cwd": wd,
        "cmd": {"name": args[0], "args": args[1:]},
    }
    sublime.set_timeout(lambda: mg9.acall("sh", a, cb), 0)
Example #16
0
def pkg_dirs(f):
	tid = gs.begin(DOMAIN, 'Fetching pkg dirs')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('pkg_dirs', {
		'env': sh.env(),
	}, cb)
Example #17
0
def imports(fn, src, toggle):
	return bcall('imports', {
		'autoinst': gs.setting('autoinst'),
		'env': sh.env(),
		'fn': fn or '',
		'src': src or '',
		'toggle': toggle or [],
		'tabIndent': gs.setting('fmt_tab_indent'),
		'tabWidth': gs.setting('fmt_tab_width'),
	})
Example #18
0
def imports(fn, src, toggle):
	return bcall('imports', {
		'autoinst': gs.setting('autoinst'),
		'env': sh.env(),
		'fn': fn or '',
		'src': src or '',
		'toggle': toggle or [],
		'tabIndent': gs.setting('fmt_tab_indent'),
		'tabWidth': gs.setting('fmt_tab_width'),
	})
Example #19
0
def import_paths(fn, src, f):
	tid = gs.begin(DOMAIN, 'Fetching import paths')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('import_paths', {
		'fn': fn or '',
		'src': src or '',
		'env': sh.env(),
	}, cb)
Example #20
0
def _complete_opts(fn, src, pos):
    home = gs.home_path()
    builtins = gs.setting("autocomplete_builtins") is True or gs.setting("complete_builtins") is True
    return {
        "Dir": gs.basedir_or_cwd(fn),
        "Builtins": builtins,
        "Fn": fn or "",
        "Src": src or "",
        "Pos": pos or 0,
        "Home": home,
        "Env": sh.env({"XDG_CONFIG_HOME": home}),
    }
Example #21
0
def declarations(fn, src, pkg_dir, f):
	tid = gs.begin(DOMAIN, 'Fetching declarations')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	return acall('declarations', {
		'fn': fn or '',
		'src': src,
		'env': sh.env(),
		'pkgDir': pkg_dir,
	}, cb)
Example #22
0
def cmd_sh(view, edit, args, wd, rkey):
	cid, cb = _9_begin_call('sh', view, edit, args, wd, rkey, '')
	a = {
		'cid': cid,
		'env': sh.env(),
		'cwd': wd,
		'cmd': {
			'name': args[0],
			'args': args[1:],
		}
	}
	sublime.set_timeout(lambda: mg9.acall('sh', a, cb), 0)
Example #23
0
def cmd_sh(view, edit, args, wd, rkey):
    cid, cb = _9_begin_call('sh', view, edit, args, wd, rkey, '')
    a = {
        'cid': cid,
        'env': sh.env(),
        'cwd': wd,
        'cmd': {
            'name': args[0],
            'args': args[1:],
        }
    }
    sublime.set_timeout(lambda: mg9.acall('sh', a, cb), 0)
Example #24
0
def declarations(fn, src, pkg_dir, f):
	tid = gs.begin(DOMAIN, 'Fetching declarations')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	return acall('declarations', {
		'fn': fn or '',
		'src': src,
		'env': sh.env(),
		'pkgDir': pkg_dir,
	}, cb)
Example #25
0
def proc(
    cmd,
    shell=False,
    env={},
    cwd=None,
    input=None,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    stdin=subprocess.PIPE,
    bufsize=0,
):
    env = sh.env(env)
    shell, cmd = fix_shell_cmd(shell, cmd)

    if input is not None:
        input = gs.astr(input)

    if cwd:
        try:
            os.makedirs(cwd)
        except Exception:
            pass
    else:
        # an empty string isn't a valid value so just always set it None
        cwd = None

    try:
        setsid = os.setsid
    except Exception:
        setsid = None

    opts = {"cmd": cmd, "shell": shell, "env": env, "input": input}

    p = None
    err = ""
    try:
        p = subprocess.Popen(
            cmd,
            stdout=stdout,
            stderr=stderr,
            stdin=stdin,
            startupinfo=gs.STARTUP_INFO,
            shell=shell,
            env=env,
            cwd=cwd,
            preexec_fn=setsid,
            bufsize=bufsize,
        )
    except Exception:
        err = "Error running command %s: %s" % (cmd, gs.traceback())

    return (p, opts, err)
Example #26
0
def imports(fn, src, toggle):
    return bcall(
        "imports",
        {
            "autoinst": gs.setting("autoinst"),
            "env": sh.env(),
            "fn": fn or "",
            "src": src or "",
            "toggle": toggle or [],
            "tabIndent": gs.setting("fmt_tab_indent"),
            "tabWidth": gs.setting("fmt_tab_width"),
        },
    )
Example #27
0
def return_package_if_inside_gopath(filename):
    env = sh.env()
    gopaths = env["GOPATH"].split(":")
    new_lines = []
    for path in gopaths:
        print("GOPATH", path)
        print("FILENA", filename)
        path = os.path.join(path, "src")
        if filename.startswith(path):
            dirname = os.path.dirname(filename.replace(path, ""))
            print(dirname)
            return dirname
    return ""
Example #28
0
def _complete_opts(fn, src, pos, builtins):
    nv = sh.env()
    return {
        "Dir": gs.basedir_or_cwd(fn),
        "Builtins": builtins,
        "Fn": fn or "",
        "Src": src or "",
        "Pos": pos or 0,
        "Home": sh.vdir(),
        "Autoinst": gs.setting("autoinst"),
        "InstallSuffix": gs.setting("installsuffix", ""),
        "Env": {"GOROOT": nv.get("GOROOT", ""), "GOPATH": nv.get("GOPATH", "")},
    }
Example #29
0
def import_paths(fn, src, f):
	tid = gs.begin(DOMAIN, 'Fetching import paths')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('import_paths', {
		'fn': fn or '',
		'src': src or '',
		'env': sh.env(),
		'WantPkgNames': gs.setting('use_named_imports'),
		'UseLegacyImports': gs.setting('use_legacy_imports'),
	}, cb)
Example #30
0
def doc(fn, src, offset, f):
	tid = gs.begin(DOMAIN, 'Fetching doc info')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('doc', {
		'fn': fn or '',
		'src': src or '',
		'offset': offset or 0,
		'env': sh.env(),
		'tabIndent': gs.setting('fmt_tab_indent'),
		'tabWidth': gs.setting('fmt_tab_width'),
	}, cb)
Example #31
0
def _complete_opts(fn, src, pos):
	home = gs.home_path()
	builtins = (gs.setting('autocomplete_builtins') is True or gs.setting('complete_builtins') is True)
	return {
		'Dir': gs.basedir_or_cwd(fn),
		'Builtins': builtins,
		'Fn':  fn or '',
		'Src': src or '',
		'Pos': pos or 0,
		'Home': home,
		'Env': sh.env({
			'XDG_CONFIG_HOME': home,
		}),
	}
Example #32
0
def doc(fn, src, offset, f):
	tid = gs.begin(DOMAIN, 'Fetching doc info')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	acall('doc', {
		'fn': fn or '',
		'src': src or '',
		'offset': offset or 0,
		'env': sh.env(),
		'tabIndent': gs.setting('fmt_tab_indent'),
		'tabWidth': gs.setting('fmt_tab_width'),
	}, cb)
Example #33
0
def cmd_go(view, edit, args, wd, rkey):
	_save_all(view.window(), wd)

	cid, cb = _9_begin_call('go', view, edit, args, wd, rkey, '9go-%s' % wd)
	a = {
		'cid': cid,
		'env': sh.env(),
		'cwd': wd,
		'cmd': {
			'name': 'go',
			'args': args,
		}
	}
	sublime.set_timeout(lambda: mg9.acall('sh', a, cb), 0)
Example #34
0
def cmd_go(view, edit, args, wd, rkey):
    _save_all(view.window(), wd)

    cid, cb = _9_begin_call('go', view, edit, args, wd, rkey, '9go-%s' % wd)
    a = {
        'cid': cid,
        'env': sh.env(),
        'cwd': wd,
        'cmd': {
            'name': 'go',
            'args': args,
        }
    }
    sublime.set_timeout(lambda: mg9.acall('sh', a, cb), 0)
Example #35
0
def a_pkgpaths(exclude, f):
	tid = gs.begin(DOMAIN, '')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	m = sh.env()
	acall('pkgpaths', {
		'env': {
			'GOPATH': m.get('GOPATH'),
			'GOROOT': m.get('GOROOT'),
			'_pathsep': m.get('_pathsep'),
		},
		'exclude': exclude,
	}, cb)
Example #36
0
def a_pkgpaths(exclude, f):
	tid = gs.begin(DOMAIN, '')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	m = sh.env()
	acall('pkgpaths', {
		'env': {
			'GOPATH': m.get('GOPATH'),
			'GOROOT': m.get('GOROOT'),
			'_pathsep': m.get('_pathsep'),
		},
		'exclude': exclude,
	}, cb)
Example #37
0
def _complete_opts(fn, src, pos, builtins):
	nv = sh.env()
	return {
		'Dir': gs.basedir_or_cwd(fn),
		'Builtins': builtins,
		'Fn':  fn or '',
		'Src': src or '',
		'Pos': pos or 0,
		'Home': sh.vdir(),
		'Autoinst': gs.setting('autoinst'),
		'Env': {
			'GOROOT': nv.get('GOROOT', ''),
			'GOPATH': nv.get('GOPATH', ''),
		},
	}
Example #38
0
def a_pkgpaths(exclude, f):
	tid = gs.begin(DOMAIN, '')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	m = sh.env()
	acall('pkgpaths', {
		'env': {
			'GOPATH': m.get('GOPATH'),
			'GOROOT': m.get('GOROOT'),
		},
		'exclude': exclude,
		'WantPkgNames': gs.setting('use_named_imports'),
	}, cb)
Example #39
0
def _complete_opts(fn, src, pos):
	home = gs.home_path()
	builtins = (gs.setting('autocomplete_builtins') is True or gs.setting('complete_builtins') is True)
	return {
		'Dir': gs.basedir_or_cwd(fn),
		'Builtins': builtins,
		'Fn':  fn or '',
		'Src': src or '',
		'Pos': pos or 0,
		'Home': home,
		'Autoinst': gs.setting('autoinst'),
		'Env': sh.env({
			'XDG_CONFIG_HOME': home,
		}),
	}
Example #40
0
def _complete_opts(fn, src, pos, builtins):
    nv = sh.env()
    return {
        'Dir': gs.basedir_or_cwd(fn),
        'Builtins': builtins,
        'Fn': fn or '',
        'Src': src or '',
        'Pos': pos or 0,
        'Home': sh.vdir(),
        'Autoinst': gs.setting('autoinst'),
        'InstallSuffix': gs.setting('installsuffix', ''),
        'Env': {
            'GOROOT': nv.get('GOROOT', ''),
            'GOPATH': nv.get('GOPATH', ''),
        },
    }
Example #41
0
def import_paths(fn, src, f):
    tid = gs.begin(DOMAIN, "Fetching import paths")

    def cb(res, err):
        gs.end(tid)
        f(res, err)

    acall(
        "import_paths",
        {
            "fn": fn or "",
            "src": src or "",
            "env": sh.env(),
            "InstallSuffix": gs.setting("installsuffix", ""),
        },
        cb,
    )
Example #42
0
def doc(fn, src, offset, f, mode='doc'):
	tid = gs.begin(DOMAIN, 'Fetching doc info')
	def cb(res, err):
		gs.end(tid)
		f(res, err)

	#default to doc
	if mode not in ['usage', 'doc']:
		mode = 'doc'

	acall(mode, {
		'fn': fn or '',
		'src': src or '',
		'offset': offset or 0,
		'env': sh.env(),
		'tabIndent': gs.setting('fmt_tab_indent'),
		'tabWidth': gs.setting('fmt_tab_width'),
	}, cb)
Example #43
0
def _complete_opts(fn, src, pos, builtins, *, forceInstall = False):
	nv = sh.env()
	return {
		'Dir': gs.basedir_or_cwd(fn),
		'Builtins': builtins,
		'Fn':  fn or '',
		'Src': src or '',
		'Pos': pos or 0,
		'Home': sh.vdir(),
		'Autoinst': gs.setting('autoinst'),
		'InstallSuffix': gs.setting('installsuffix', ''),
		'Env': {
			'GOROOT': nv.get('GOROOT', ''),
			'GOPATH': nv.get('GOPATH', ''),
			'TEMP': nv.get('TEMP', ''),
			'TMP': nv.get('TMP', ''),
			'FORCE_INSTALL': str(int(forceInstall)),
		},
	}
Example #44
0
def cmd_cd(view, edit, args, wd, rkey):
	try:
		if args:
			wd = args[0]
			wd = string.Template(wd).safe_substitute(sh.env())
			wd = os.path.expanduser(wd)
			wd = os.path.abspath(wd)
		else:
			fn = view.window().active_view().file_name()
			if fn:
				wd = os.path.dirname(fn)

		os.chdir(wd)
	except Exception as ex:
		push_output(view, rkey, 'Cannot chdir: %s' % ex)
		return

	push_output(view, rkey, '')
	view.run_command('gs9o_init', {'wd': wd})
Example #45
0
def cmd_cd(view, edit, args, wd, rkey):
    try:
        if args:
            wd = args[0]
            wd = string.Template(wd).safe_substitute(sh.env())
            wd = os.path.expanduser(wd)
            wd = os.path.abspath(wd)
        else:
            fn = view.window().active_view().file_name()
            if fn:
                wd = os.path.dirname(fn)

        os.chdir(wd)
    except Exception as ex:
        push_output(view, rkey, 'Cannot chdir: %s' % ex)
        return

    push_output(view, rkey, '')
    view.run_command('gs9o_init', {'wd': wd})
Example #46
0
def _complete_opts(fn, src, pos, builtins, *, forceInstall=False):
    nv = sh.env()
    return {
        'Dir': gs.basedir_or_cwd(fn),
        'Builtins': builtins,
        'Fn': fn or '',
        'Src': src or '',
        'Pos': pos or 0,
        'Home': sh.vdir(),
        'Autoinst': gs.setting('autoinst'),
        'InstallSuffix': gs.setting('installsuffix', ''),
        'Env': {
            'GOROOT': nv.get('GOROOT', ''),
            'GOPATH': nv.get('GOPATH', ''),
            'TEMP': nv.get('TEMP', ''),
            'TMP': nv.get('TMP', ''),
            'FORCE_INSTALL': str(int(forceInstall)),
        },
    }
Example #47
0
    def on_query_completions(self, view, _, locations):
        pos = locations[0]
        if view.score_selector(pos, 'text.9o') == 0:
            return []

        if view.substr(locations[0] - 2) == '$':
            return ([('$' + k, '\$' + k + ' ') for k in sh.env()], AC_OPTS)

        cl = set()

        slash = os.path.sep
        # the prefix passed tho us by definition doesn't contain slash because it's not a word char
        p = view.substr(sublime.Region(view.line(pos).begin(), pos))
        p = p.split()[-1].lstrip(' #')
        file_only_comp = p.startswith('.') or slash in p

        if not p.startswith(('.', slash)):
            p = '.' + slash + p

        rm = ''
        m = word_sep_pat.match(p)
        if m:
            rm = m.group(1)

        try:
            for fn in glob.iglob(p + '*'):
                space = ' '
                if os.path.isdir(fn):
                    space = ''
                    fn += '/'

                cl.add((fn, fn[len(rm):] + space))
        except Exception:
            pass

        if not file_only_comp:
            hkey = _hkey(view.settings().get('9o.wd', ''))
            cl.update((k, k + ' ') for k in gs.dval(gs.aso().get(hkey), []))
            cl.update((k, k + ' ') for k in builtins())
            cl.update(DEFAULT_CL)

        return ([cl_esc(e) for e in sorted(cl)], AC_OPTS)
Example #48
0
def fmt(fn, src):
    st = gs.settings_dict()
    x = st.get('fmt_cmd')
    if x:
        res, err = bcall(
            'sh', {
                'Env': sh.env(),
                'Cmd': {
                    'Name': x[0],
                    'Args': x[1:],
                    'Input': src or '',
                },
            })
        return res.get('out', ''), (err or res.get('err', ''))

    res, err = bcall(
        'fmt', {
            'Fn': fn or '',
            'Src': src or '',
            'TabIndent': st.get('fmt_tab_indent'),
            'TabWidth': st.get('fmt_tab_width'),
        })
    return res.get('src', ''), err
Example #49
0
    def run(self, edit, save_hist=False):
        view = self.view
        pos = gs.sel(view).begin()
        line = view.line(pos)
        wd = view.settings().get('9o.wd')

        try:
            os.chdir(wd)
        except Exception:
            gs.error_traceback(DOMAIN)

        ln = view.substr(line).split('#', 1)
        if len(ln) == 2:
            cmd = ln[1].strip()
            if cmd:
                vs = view.settings()
                aso = gs.aso()
                hkey = _hkey(wd)
                hist = gs.dval(aso.get(hkey), [])

                m = HIST_EXPAND_PAT.match(cmd)
                if m:
                    pfx = m.group(1)
                    hl = len(hist)
                    idx = hl - int(m.group(2))
                    cmd = ''
                    if idx >= 0 and idx < hl:
                        cmd = hist[idx]

                    if pfx == '^' or not cmd:
                        view.replace(edit, line, ('%s# %s' % (ln[0], cmd)))
                        return
                elif save_hist:
                    try:
                        hist.remove(cmd)
                    except ValueError:
                        pass
                    hist.append(cmd)
                    aso.set(hkey, hist)
                    gs.save_aso()

            if not cmd:
                view.run_command('gs9o_init')
                return

            view.replace(edit, line, (u'[ `%s` %s ]' % (cmd, HOURGLASS)))
            rkey = '9o.exec.%s' % uuid.uuid4()
            view.add_regions(rkey, [sublime.Region(line.begin(), view.size())],
                             '')
            view.run_command('gs9o_init')

            nv = sh.env()
            anv = nv.copy()
            seen = {}
            am = aliases()
            while True:
                cli = cmd.split(' ', 1)
                nm = cli[0]
                if not nm:
                    break

                ag = cli[1].strip() if len(cli) == 2 else ''

                alias = am.get(nm, '')
                if not alias:
                    break

                if alias in seen:
                    gs.error(DOMAIN, 'recursive alias detected: `%s`' % alias)
                    break

                seen[alias] = True
                anv['_args'] = ag
                cmd = string.Template(alias).safe_substitute(anv)

            if nm != 'sh':
                f = builtins().get(nm)
                if f:
                    args = []
                    if ag:
                        args = [
                            _exparg(s, nv) for s in shlex.split(gs.astr(ag))
                        ]

                    f(view, edit, args, wd, rkey)
                    return

            if nm == 'sh':
                args = sh.cmd(ag)
            else:
                args = sh.cmd(cmd)

            cmd_sh(view, edit, args, wd, rkey)
        else:
            view.insert(edit, gs.sel(view).begin(), '\n')
Example #50
0
def _exec(view, edit, save_hist=False):
    pos = gs.sel(view).begin()
    line = view.line(pos)
    wd = view.settings().get('9o.wd')

    try:
        os.chdir(wd)
    except Exception:
        ui.trace(DOMAIN)

    ln = view.substr(line).split('#', 1)
    if len(ln) == 2:
        cmd = ln[1].strip()
        if cmd:
            vs = view.settings()
            aso = gs.aso()
            hkey = _hkey(wd)
            hist = gs.dval(aso.get(hkey), [])

            m = HIST_EXPAND_PAT.match(cmd)
            if m:
                pfx = m.group(1)
                hl = len(hist)
                idx = hl - int(m.group(2))
                cmd = ''
                if idx >= 0 and idx < hl:
                    cmd = hist[idx]

                if pfx == '^' or not cmd:
                    view.replace(edit, line, ('%s# %s' % (ln[0], cmd)))
                    return
            elif save_hist:
                try:
                    hist.remove(cmd)
                except ValueError:
                    pass
                hist.append(cmd)
                aso.set(hkey, hist)
                gs.save_aso()

        if not cmd:
            view.run_command('gs9o_init')
            return

        line = view.full_line(pos)
        ctx = '9o.exec.%s' % gs.uid()
        view.replace(edit, line, ('[`%s`]\n' % cmd))
        view.run_command('gs9o_init')
        ep = view.full_line(line.begin()).end()
        view.add_regions(ctx, [sublime.Region(ep, ep)], '')
        hellip = u'[ \u22EF ]'
        ep += 1
        view.insert(edit, ep, hellip + '\n\n')
        view.add_regions(ctx + '.done', [sublime.Region(ep, ep + len(hellip))],
                         '')

        cli = cmd.split(' ', 1)
        if cli[0] == 'sh':
            a = cli[1].strip() if len(cli) == 2 else ''
            mk_cmd(view, wd, ctx, sh.cmd(a)).start()
            return

        nv = sh.env()
        a = [_exparg(s, nv) for s in shlex.split(gs.astr(cmd))]
        f = builtins().get(a[0])
        if f:
            f(view, edit, a[1:], wd, ctx)
        else:
            mk_cmd(view, wd, ctx, a).start()

    else:
        view.insert(edit, gs.sel(view).begin(), '\n')
Example #51
0
def cmd_env(view, edit, args, wd, rkey):
    _env_settings(sh.env(), view, edit, args, wd, rkey)
Example #52
0
def install(aso_install_vesion, force_install, _reinstall=False):
    global INSTALL_EXE

    if not _reinstall and _inst_state() != "":
        gs.notify(
            DOMAIN,
            'Installation aborted. Install command already called for GoSublime %s.'
            % INSTALL_VERSION)
        return ''

    INSTALL_EXE = INSTALL_EXE.replace('_%s.exe' % about.DEFAULT_GO_VERSION,
                                      '_%s.exe' % sh.GO_VERSION)
    about.MARGO_EXE = INSTALL_EXE

    is_update = about.VERSION != INSTALL_VERSION

    gs.set_attr(_inst_name(), 'busy')

    init_start = time.time()

    if not _reinstall and not is_update and not force_install and _bins_exist(
    ) and aso_install_vesion == INSTALL_VERSION:
        m_out = 'no'
    else:
        gs.notify('GoSublime', 'Installing MarGo')
        start = time.time()

        cmd = sh.Command([
            'go',
            'build',
            '-tags',
            'gosublime' if ext_main_file() else '',
            '-v',
            '-o',
            INSTALL_EXE,
            'gosublime/cmd/margo',
        ])
        cmd.wd = gs.home_dir_path('bin')
        cmd.env = {
            'CGO_ENABLED': '0',
            'GOBIN': '',
            'GOPATH': install_gopath(),
        }

        ev.debug('%s.build' % DOMAIN, {
            'cmd': cmd.cmd_lst,
            'cwd': cmd.wd,
        })

        cr = cmd.run()
        m_out = 'cmd: `%s`\nstdout: `\n%s\n`\nstderr: `\n%s\n`\nexception: `%s`' % (
            cr.cmd_lst,
            cr.out.strip(),
            cr.err.strip(),
            cr.exc,
        )

        if cr.ok and _bins_exist():

            def f():
                gs.aso().set('install_version', INSTALL_VERSION)
                gs.save_aso()

            sublime.set_timeout(f, 0)
        else:
            err_prefix = 'MarGo build failed'
            gs.error(DOMAIN, '%s\n%s' % (err_prefix, m_out))

            sl = [('GoSublime error', '\n'.join((
                err_prefix,
                'This is possibly a bug or miss-configuration of your environment.',
                'For more help, please file an issue with the following build output',
                'at: https://github.com/DisposaBoy/GoSublime/issues/new',
                'or alternatively, you may send an email to: [email protected]',
                '\n',
                m_out,
            )))]
            sl.extend(sanity_check({}, False))
            gs.show_output('GoSublime', '\n'.join(sanity_check_sl(sl)))

    gs.set_attr(_inst_name(), 'done')

    if is_update:
        gs.show_output(
            'GoSublime-source', '\n'.join([
                'GoSublime source has been updated.',
                'New version: `%s`, current version: `%s`' %
                (INSTALL_VERSION, about.VERSION),
                'Please restart Sublime Text to complete the update.',
            ]))
    else:
        e = sh.env()
        a = [
            'GoSublime init %s (%0.3fs)' %
            (INSTALL_VERSION, time.time() - init_start),
        ]

        sl = [('install margo', m_out)]
        sl.extend(sanity_check(e))
        a.extend(sanity_check_sl(sl))
        gs.println(*a)

        missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
        if missing:
            missing_message = '\n'.join([
                'Missing required environment variables: %s' %
                ' '.join(missing),
                'See the `Quirks` section of USAGE.md for info',
            ])

            cb = lambda ok: gs.show_output(
                DOMAIN, missing_message, merge_domain=True, print_output=False)
            gs.error(DOMAIN, missing_message)
            gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)

        killSrv()

        start = time.time()
        # acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))

        report_x = lambda: gs.println(
            "GoSublime: Exception while cleaning up old binaries",
            gs.traceback())
        try:
            bin_dirs = [
                gs.home_path('bin'),
            ]

            l = []
            for d in bin_dirs:
                try:
                    for fn in os.listdir(d):
                        if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
                            l.append(os.path.join(d, fn))
                except Exception:
                    pass

            for fn in l:
                try:
                    gs.println("GoSublime: removing old binary: `%s'" % fn)
                    os.remove(fn)
                except Exception:
                    report_x()

        except Exception:
            report_x()

    return m_out