def link_builtins(self, execer=None):
# public built-ins
proxy_mapping = {
"XonshError": "__xonsh__.builtins.XonshError",
"XonshCalledProcessError":
"__xonsh__.builtins.XonshCalledProcessError",
"evalx": "__xonsh__.builtins.evalx",
"execx": "__xonsh__.builtins.execx",
"compilex": "__xonsh__.builtins.compilex",
"events": "__xonsh__.builtins.events",
"print_color": "__xonsh__.builtins.print_color",
"printx": "__xonsh__.builtins.printx",
}
for refname, objname in proxy_mapping.items():
proxy = DynamicAccessProxy(refname, objname)
setattr(builtins, refname, proxy)
# sneak the path search functions into the aliases
# Need this inline/lazy import here since we use locate_binary that
# relies on __xonsh__.env in default aliases
builtins.default_aliases = builtins.aliases = Aliases(
make_default_aliases())
atexit.register(_lastflush)
for sig in AT_EXIT_SIGNALS:
resetting_signal_handle(sig, _lastflush)
def test_recursive_callable_partial_none(xonsh_execer, xonsh_builtins):
ales = Aliases({"rtn": _return_to_sender_none, "rtn-recurse": ["rtn"]})
alias = ales.get("rtn-recurse")
assert callable(alias)
args, obs = alias()
assert args == "wakka"
assert len(obs) == 0
def test_rich_completion(completion, lprefix, ptk_completion, monkeypatch,
xonsh_builtins):
xonsh_completer_mock = MagicMock()
xonsh_completer_mock.complete.return_value = {completion}, lprefix
ptk_completer = PromptToolkitCompleter(xonsh_completer_mock, None, None)
ptk_completer.reserve_space = lambda: None
ptk_completer.suggestion_completion = lambda _, __: None
document_mock = MagicMock()
document_mock.text = ''
document_mock.current_line = ''
document_mock.cursor_position_col = 0
monkeypatch.setattr('builtins.aliases', Aliases())
completions = list(
ptk_completer.get_completions(document_mock, MagicMock()))
if isinstance(completion, RichCompletion) and not ptk_completion:
assert completions == [
PTKCompletion(completion, -completion.prefix_len,
completion.display, completion.description)
]
else:
assert completions == [ptk_completion]
def load_builtins(execer=None, config=None, login=False, ctx=None):
"""Loads the xonsh builtins into the Python builtins. Sets the
BUILTINS_LOADED variable to True.
"""
global BUILTINS_LOADED
# private built-ins
builtins.__xonsh_config__ = {}
builtins.__xonsh_env__ = env = Env(default_env(config=config, login=login))
builtins.__xonsh_help__ = helper
builtins.__xonsh_superhelp__ = superhelper
builtins.__xonsh_pathsearch__ = pathsearch
builtins.__xonsh_globsearch__ = globsearch
builtins.__xonsh_regexsearch__ = regexsearch
builtins.__xonsh_glob__ = globpath
builtins.__xonsh_expand_path__ = expand_path
builtins.__xonsh_exit__ = False
builtins.__xonsh_stdout_uncaptured__ = None
builtins.__xonsh_stderr_uncaptured__ = None
if hasattr(builtins, 'exit'):
builtins.__xonsh_pyexit__ = builtins.exit
del builtins.exit
if hasattr(builtins, 'quit'):
builtins.__xonsh_pyquit__ = builtins.quit
del builtins.quit
builtins.__xonsh_subproc_captured_stdout__ = subproc_captured_stdout
builtins.__xonsh_subproc_captured_inject__ = subproc_captured_inject
builtins.__xonsh_subproc_captured_object__ = subproc_captured_object
builtins.__xonsh_subproc_captured_hiddenobject__ = subproc_captured_hiddenobject
builtins.__xonsh_subproc_uncaptured__ = subproc_uncaptured
builtins.__xonsh_execer__ = execer
builtins.__xonsh_commands_cache__ = CommandsCache()
builtins.__xonsh_all_jobs__ = {}
builtins.__xonsh_ensure_list_of_strs__ = ensure_list_of_strs
builtins.__xonsh_list_of_strs_or_callables__ = list_of_strs_or_callables
builtins.__xonsh_completers__ = xonsh.completers.init.default_completers()
builtins.__xonsh_call_macro__ = call_macro
builtins.__xonsh_enter_macro__ = enter_macro
# public built-ins
builtins.XonshError = XonshError
builtins.XonshBlockError = XonshBlockError
builtins.XonshCalledProcessError = XonshCalledProcessError
builtins.evalx = None if execer is None else execer.eval
builtins.execx = None if execer is None else execer.exec
builtins.compilex = None if execer is None else execer.compile
builtins.events = events
# sneak the path search functions into the aliases
# Need this inline/lazy import here since we use locate_binary that relies on __xonsh_env__ in default aliases
builtins.default_aliases = builtins.aliases = Aliases(make_default_aliases())
if login:
builtins.aliases.update(load_foreign_aliases(issue_warning=False))
# history needs to be started after env and aliases
# would be nice to actually include non-detyped versions.
builtins.__xonsh_history__ = History(env=env.detype(),
ts=[time.time(), None], locked=True)
atexit.register(_lastflush)
for sig in AT_EXIT_SIGNALS:
resetting_signal_handle(sig, _lastflush)
BUILTINS_LOADED = True
def load_builtins(execer=None, ctx=None):
"""Loads the xonsh builtins into the Python builtins. Sets the
BUILTINS_LOADED variable to True.
"""
global BUILTINS_LOADED
# private built-ins
builtins.__xonsh_config__ = {}
builtins.__xonsh_env__ = Env(default_env())
builtins.__xonsh_help__ = helper
builtins.__xonsh_superhelp__ = superhelper
builtins.__xonsh_pathsearch__ = pathsearch
builtins.__xonsh_globsearch__ = globsearch
builtins.__xonsh_regexsearch__ = regexsearch
builtins.__xonsh_glob__ = globpath
builtins.__xonsh_expand_path__ = expand_path
builtins.__xonsh_exit__ = False
builtins.__xonsh_stdout_uncaptured__ = None
builtins.__xonsh_stderr_uncaptured__ = None
if hasattr(builtins, "exit"):
builtins.__xonsh_pyexit__ = builtins.exit
del builtins.exit
if hasattr(builtins, "quit"):
builtins.__xonsh_pyquit__ = builtins.quit
del builtins.quit
builtins.__xonsh_subproc_captured_stdout__ = subproc_captured_stdout
builtins.__xonsh_subproc_captured_inject__ = subproc_captured_inject
builtins.__xonsh_subproc_captured_object__ = subproc_captured_object
builtins.__xonsh_subproc_captured_hiddenobject__ = subproc_captured_hiddenobject
builtins.__xonsh_subproc_uncaptured__ = subproc_uncaptured
builtins.__xonsh_execer__ = execer
builtins.__xonsh_commands_cache__ = CommandsCache()
builtins.__xonsh_all_jobs__ = {}
builtins.__xonsh_ensure_list_of_strs__ = ensure_list_of_strs
builtins.__xonsh_list_of_strs_or_callables__ = list_of_strs_or_callables
builtins.__xonsh_list_of_list_of_strs_outer_product__ = (
list_of_list_of_strs_outer_product)
builtins.__xonsh_completers__ = xonsh.completers.init.default_completers()
builtins.__xonsh_call_macro__ = call_macro
builtins.__xonsh_enter_macro__ = enter_macro
builtins.__xonsh_path_literal__ = path_literal
# public built-ins
builtins.XonshError = XonshError
builtins.XonshCalledProcessError = XonshCalledProcessError
builtins.evalx = None if execer is None else execer.eval
builtins.execx = None if execer is None else execer.exec
builtins.compilex = None if execer is None else execer.compile
builtins.events = events
# sneak the path search functions into the aliases
# Need this inline/lazy import here since we use locate_binary that
# relies on __xonsh_env__ in default aliases
builtins.default_aliases = builtins.aliases = Aliases(
make_default_aliases())
builtins.__xonsh_history__ = None
atexit.register(_lastflush)
for sig in AT_EXIT_SIGNALS:
resetting_signal_handle(sig, _lastflush)
BUILTINS_LOADED = True
def test_recursive_callable_partial_handles(xonsh_execer, xonsh_builtins):
ales = Aliases({"rtn": _return_to_sender_handles, "rtn-recurse": ["rtn", "arg1"]})
alias = ales.get("rtn-recurse")
assert callable(alias)
args, obs = alias(["arg2"], stdin="a", stdout="b", stderr="c")
assert args == ["arg1", "arg2"]
assert len(obs) == 3
exp = {"stdin": "a", "stdout": "b", "stderr": "c"}
assert obs == exp
def make_aliases():
ales = Aliases(
{"o": ["omg", "lala"]},
color_ls=["ls", "--color=true"],
ls="ls '- -'",
cd=cd,
indirect_cd="cd ..",
)
return ales
def xonsh_builtins(monkeypatch, xonsh_events, session_vars):
"""Mock out most of the builtins xonsh attributes."""
old_builtins = dict(vars(builtins).items()) # type: ignore
XSH.load(ctx={}, **session_vars)
def locate_binary(self, name):
return os.path.join(os.path.dirname(__file__), "bin", name)
for attr, val in [
("env", DummyEnv()),
("shell", DummyShell()),
("help", lambda x: x),
("aliases", Aliases()),
("exit", False),
("history", DummyHistory()),
# ("subproc_captured", sp),
("subproc_uncaptured", sp),
("subproc_captured_stdout", sp),
("subproc_captured_inject", sp),
("subproc_captured_object", sp),
("subproc_captured_hiddenobject", sp),
]:
monkeypatch.setattr(XSH, attr, val)
if ON_WINDOWS:
XSH.env["PATHEXT"] = [".EXE", ".BAT", ".CMD"]
cc = XSH.commands_cache
monkeypatch.setattr(cc, "locate_binary",
types.MethodType(locate_binary, cc))
monkeypatch.setattr(cc, "_cmds_cache", {})
for attr, val in [
("evalx", eval),
("execx", None),
("compilex", None),
# Unlike all the other stuff, this has to refer to the "real" one because all modules that would
# be firing events on the global instance.
("events", xonsh_events),
]:
# attributes to builtins are dynamicProxy and should pickup the following
monkeypatch.setattr(XSH.builtins, attr, val)
# todo: remove using builtins for tests at all
yield builtins
XSH.unload()
for attr in set(dir(builtins)) - set(old_builtins):
if hasattr(builtins, attr):
delattr(builtins, attr)
for attr, old_value in old_builtins.items():
setattr(builtins, attr, old_value)
tasks.clear() # must to this to enable resetting all_jobs
def factory(*attrs: str):
"""
Parameters
----------
attrs
do not mock the given attributes
Returns
-------
XonshSession
with most of the attributes mocked out
"""
if session:
raise RuntimeError(
"The factory should be called only once per test")
for attr, val in [
("env", env),
("shell", DummyShell()),
("help", lambda x: x),
("aliases", Aliases()),
("exit", False),
("history", DummyHistory()),
(
"commands_cache",
commands_cache.CommandsCache(),
), # since env,aliases change , patch cmds-cache
# ("subproc_captured", sp),
("subproc_uncaptured", sp),
("subproc_captured_stdout", sp),
("subproc_captured_inject", sp),
("subproc_captured_object", sp),
("subproc_captured_hiddenobject", sp),
]:
if attr in attrs:
continue
monkeypatch.setattr(xonsh_session, attr, val)
for attr, val in [
("evalx", eval),
("execx", None),
("compilex", None),
# Unlike all the other stuff, this has to refer to the "real" one because all modules that would
# be firing events on the global instance.
("events", xonsh_events),
]:
# attributes to builtins are dynamicProxy and should pickup the following
monkeypatch.setattr(xonsh_session.builtins, attr, val)
session.append(xonsh_session)
return xonsh_session
def link_builtins(self, aliases=None):
from xonsh.aliases import Aliases, make_default_aliases
# public built-ins
for refname in self._initial_builtin_names:
objname = f"__xonsh__.builtins.{refname}"
proxy = DynamicAccessProxy(refname, objname)
setattr(builtins, refname, proxy)
# sneak the path search functions into the aliases
# Need this inline/lazy import here since we use locate_binary that
# relies on __xonsh__.env in default aliases
if aliases is None:
aliases = Aliases(make_default_aliases())
self.aliases = builtins.default_aliases = builtins.aliases = aliases
def test_register_decorator(xession):
aliases = Aliases()
@aliases.register
def debug():
...
@aliases.register("name")
def with_options():
...
@aliases.register
def _private():
...
assert set(aliases) == {"debug", "name", "private"}
def test_alias_expansion(code, index, expected_args, monkeypatch, xession):
xonsh_completer_mock = MagicMock(spec=Completer)
xonsh_completer_mock.complete.return_value = set(), 0
ptk_completer = PromptToolkitCompleter(xonsh_completer_mock, None, None)
ptk_completer.reserve_space = lambda: None
ptk_completer.suggestion_completion = lambda _, __: None
monkeypatch.setattr(xession, "aliases", Aliases(gb=["git branch"]))
list(ptk_completer.get_completions(Document(code, index), MagicMock()))
mock_call = xonsh_completer_mock.complete.call_args
args, kwargs = mock_call
expected_args["self"] = None
expected_args["ctx"] = None
assert (signature(Completer.complete).bind(
None, *args, **kwargs).arguments == expected_args)
def test_recursive_callable_partial_all(xonsh_builtins):
ales = Aliases({
"rtn": _return_to_sender_all,
"rtn-recurse": ["rtn", "arg1"]
})
alias = ales.get("rtn-recurse")
assert callable(alias)
args, obs = alias(["arg2"],
stdin="a",
stdout="b",
stderr="c",
spec="d",
stack="e")
assert args == ["arg1", "arg2"]
assert len(obs) == 5
exp = {
"stdin": "a",
"stdout": "b",
"stderr": "c",
"spec": "d",
"stack": "e"
}
assert obs == exp
def test_completion_alias_expansion(
code,
index,
expected_args,
monkeypatch,
xession,
):
xonsh_completer_mock = MagicMock(spec=Completer)
xonsh_completer_mock.complete.return_value = set(), 0
kernel = MagicMock()
kernel.completer = xonsh_completer_mock
monkeypatch.setattr(xession, "aliases", Aliases(gb=["git branch"]))
monkeypatch.setattr(xession.shell, "ctx", None, raising=False)
XonshKernel.do_complete(kernel, code, index)
mock_call = xonsh_completer_mock.complete.call_args
args, kwargs = mock_call
expected_args["self"] = None
expected_args["ctx"] = None
assert (signature(Completer.complete).bind(
None, *args, **kwargs).arguments == expected_args)
def xsh_with_aliases(xession, monkeypatch):
from xonsh.aliases import Aliases, make_default_aliases
xsh = xession
monkeypatch.setattr(xsh, "aliases", Aliases(make_default_aliases()))
return xsh
import xonsh.built_ins as built_ins
from xonsh.aliases import Aliases
from xonsh.environ import Env
from tools import skip_if_on_windows
def cd(args, stdin=None):
return args
ALIASES = Aliases(
{"o": ["omg", "lala"]},
color_ls=["ls", "--color=true"],
ls="ls '- -'",
cd=cd,
indirect_cd="cd ..",
)
RAW = ALIASES._raw
def test_imports():
expected = {
"o": ["omg", "lala"],
"ls": ["ls", "- -"],
"color_ls": ["ls", "--color=true"],
"cd": cd,
"indirect_cd": ["cd", ".."],
}
assert RAW == expected
import xonsh.built_ins as built_ins
from xonsh.aliases import Aliases
from xonsh.aliases import _which
from xonsh.environ import Env
from xonsh.tools import ON_WINDOWS
from tools import skip_if_on_windows
def cd(args, stdin=None):
return args
ALIASES = Aliases({'o': ['omg', 'lala']},
color_ls=['ls', '--color=true'],
ls="ls '- -'",
cd=cd,
indirect_cd='cd ..')
RAW = ALIASES._raw
def test_imports():
expected = {
'o': ['omg', 'lala'],
'ls': ['ls', '- -'],
'color_ls': ['ls', '--color=true'],
'cd': cd,
'indirect_cd': ['cd', '..']
}
assert RAW == expected