xmyshell 0.2.11__tar.gz → 0.2.13__tar.gz

{xmyshell-0.2.11/xmyshell.egg-info → xmyshell-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmyshell
-Version: 0.2.11
+Version: 0.2.13
 Summary: XmyShell is a shell-like tool built on top of prompt_toolkit which provides a persistent Python runtime.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -163,6 +163,12 @@ The exit code of the last command.
 - `exec_duration`
 The duration which last command took.
 
+- `SHOW_WELCOME`
+Toggle whether to show welcome message when staring.
+
+- `SHELL_CMD`
+Shell command line prefix, defaults to `["cmd", "/c"]` on Windows and `["bin/sh", "-c"]` on other OS.
+
 - `HOME_DIR`
 The home directory, similar to `~`.
 

{xmyshell-0.2.11 → xmyshell-0.2.13}/README.md

@@ -153,6 +153,12 @@ The exit code of the last command.
 - `exec_duration`
 The duration which last command took.
 
+- `SHOW_WELCOME`
+Toggle whether to show welcome message when staring.
+
+- `SHELL_CMD`
+Shell command line prefix, defaults to `["cmd", "/c"]` on Windows and `["bin/sh", "-c"]` on other OS.
+
 - `HOME_DIR`
 The home directory, similar to `~`.
 

{xmyshell-0.2.11 → xmyshell-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xmyshell"
-version = "0.2.11"
+version = "0.2.13"
 description = "XmyShell is a shell-like tool built on top of prompt_toolkit which provides a persistent Python runtime."
 readme = "README.md"
 requires-python = ">=3.12"

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/completer.py

@@ -1,5 +1,6 @@
 from collections.abc import Generator, Iterable
 import os
+import shlex
 import sys
 import re
 import time
@@ -118,16 +119,51 @@ class ShellCompleter(Completer):
         others = sorted(c for c in commands if c not in COMMON and c not in BUILTINS)
         return builtins + common + others
 
-    def _path_completions(self, text: str, max_results: int = 100):
+    def _path_completions(self, text: str, max_results: int = 100, in_string: bool=False):
         if text and text[-1] in whitespace: return
-        last = text.split()[-1] if text.split() else ""
+
+        def last_token_raw(text: str) -> str:
+            quote = None
+            start = 0
+            i = 0
+            while i < len(text):
+                ch = text[i]
+                if quote:
+                    if ch == quote:
+                        quote = None
+                    elif ch == "\\" and quote == '"':
+                        i += 1
+                else:
+                    if ch in ("'", '"'):
+                        quote = ch
+                    elif ch in " \t":
+                        start = i + 1
+                    elif ch == "\\":
+                        i += 1
+                i += 1
+            return text[start:]
+
+        def start_pos(text: str, prefix: str) -> int:
+            original_len = len(text)
+            if text and text[-1] in ("'", '"') and not text.endswith(prefix):
+                text = text[:-1]
+            if not prefix or not text.endswith(prefix):
+                return -len(prefix)
+            start = len(text) - len(prefix)
+            if start > 0 and text[start - 1] in ("'", '"'):
+                start -= 1
+            return start - original_len
+
+        last = last_token_raw(text)
+        in_string = in_string or last.startswith('"') or last.startswith("'")
+        last = last.lstrip('"\'')
         if last == '~': return  # don't remove this
         path = os.path.expanduser(last)
         dirname = os.path.dirname(path) or "."
-        prefix = os.path.basename(path)
+        prefix = os.path.basename(path).strip('"\'')
 
         try:
-            matches = []
+            matches: list[str] = []
             for item in os.listdir(dirname):
                 if item.startswith(prefix):
                     matches.append(item)
@@ -137,11 +173,14 @@ class ShellCompleter(Completer):
             for item in sorted(matches):
                 full = os.path.join(dirname, item)
                 is_dir = os.path.isdir(full)
-                name = item + ("/" if is_dir else "")
+                if ' ' in item and not in_string:
+                    name = f'"{item}"'
+                else:
+                    name = item
                 yield Completion(
                     name,
-                    display=truncate(name, MAX_DISPLAY_LEN),
-                    start_position=-len(prefix),
+                    display=truncate(item, MAX_DISPLAY_LEN),
+                    start_position=start_pos(text, prefix),
                     display_meta="directory" if is_dir else "file",
                 )
         except OSError:
@@ -207,7 +246,7 @@ class ShellCompleter(Completer):
 
         string = _in_string(text)
         if string:
-            yield from self._path_completions(string)
+            yield from self._path_completions(string, in_string=True)
             return
 
         if text and text[-1].isspace():

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/environment.py

@@ -10,6 +10,7 @@ from .utils import XMYSHELL_MAGIC, getcwd, getlogin, HOME_DIR, xmyshell_cat
 namespace: dict[str, Any] = {}
 aliases: dict[str, str] = {}
 init_environ: dict[str, str] = dict(os.environ)
+SHELL_CMD = ["cmd", "/c"] if os.name == "nt" else ["/bin/sh", "-c"]
 
 
 def xmyshell_alias(altname: str, target: str) -> None:
@@ -34,6 +35,8 @@ _init_namespace: dict[str, Any] = {
     "cat": xmyshell_cat,
     "alias": xmyshell_alias,
     "unalias": xmyshell_unalias,
+    "SHOW_WELCOME": True,
+    "SHELL_CMD": SHELL_CMD,
     "HOME_DIR": HOME_DIR,
     "PROFILE": f"{HOME_DIR}/.xmyshell/config.py",
     "exit_code": 0,

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/kernel.py

@@ -1,11 +1,13 @@
 from collections.abc import Generator, Sequence
+from contextlib import contextmanager
 import os
 import sys
+import re
 import runpy
 import subprocess
 import signal
 import shlex
-from .environment import namespace, aliases, xmyshell_alias, xmyshell_unalias
+from .environment import namespace, aliases, xmyshell_alias, xmyshell_unalias, SHELL_CMD
 from .utils import pywarning, pyerror, getcwd
 from .meta import HELP_MESSAGE
 
@@ -14,8 +16,20 @@ def _reload() -> None:
     from .init import xmyshell_reload
     xmyshell_reload()
 
+def _reset_sigint():
+    signal.signal(signal.SIGINT, signal.SIG_DFL)
 
-def _run(*args, **kwargs) -> subprocess.CompletedProcess:
+_kwargs_preexec = {}
+if os.name == "posix":
+    _kwargs_preexec["preexec_fn"] = _reset_sigint
+
+@contextmanager
+def _no_interrupt():
+    old = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    yield
+    signal.signal(signal.SIGINT, old)
+
+def _run(cmd_line: list[str] | str, **kwargs) -> subprocess.CompletedProcess:
     # Block SIGINT in the parent while the child runs, so that a Ctrl-C
     # delivered to the console/process group is handled solely by the child.
     #
@@ -26,17 +40,15 @@ def _run(*args, **kwargs) -> subprocess.CompletedProcess:
     # KeyboardInterrupt handler only fires for Ctrl-C at the prompt.
     #
     # Must run on the main thread: signal.signal() is not allowed elsewhere.
-    kwargs_preexec = {}
-    if os.name == "posix":
-        def _reset_sigint():
-            signal.signal(signal.SIGINT, signal.SIG_DFL)
-        kwargs_preexec["preexec_fn"] = _reset_sigint
-    old = signal.signal(signal.SIGINT, signal.SIG_IGN)
-    try:
-        return subprocess.run(*args, **kwargs_preexec, **kwargs)
-    finally:
-        signal.signal(signal.SIGINT, old)
-
+    with _no_interrupt():
+        if isinstance(cmd_line, list):
+            return subprocess.run(cmd_line, **_kwargs_preexec, **kwargs)
+        else:
+            return subprocess.run(
+                namespace.get("SHELL_CMD", SHELL_CMD) + [cmd_line],
+                **_kwargs_preexec,
+                **kwargs,
+            )
 
 def xmyshell_source(path: str) -> None:
     _updated = runpy.run_path(
@@ -250,29 +262,30 @@ def xmyshell(cmd_line: str) -> int:
         cmd_line, sh_cmd = cmd_line.split("|>", 1)
 
     if sh_cmd:
-        proc = subprocess.Popen(
-            sh_cmd,
-            shell=True,
-            env=os.environ,
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            text=True,
-        )
-        old_stdout = sys.stdout
-        sys.stdout = proc.stdin
-        return_code = xmyshell_raw_command(cmd_line)
-        if return_code is None:
-            pyerror(f"'{cmd_line}' cannot be used in a pipeline with '|>'")
-            return -1
-        assert proc.stdin
-        proc.stdin.close()
-        sys.stdout = old_stdout
-        if target_var:
-            result, _ = proc.communicate()
-            namespace[target_var] = result
-            return proc.returncode
-        else:
-            return proc.wait()
+        with _no_interrupt():
+            proc = subprocess.Popen(
+                namespace.get("SHELL_CMD", SHELL_CMD) + [sh_cmd],
+                env=os.environ,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                text=True,
+                **_kwargs_preexec,
+            )
+            old_stdout = sys.stdout
+            sys.stdout = proc.stdin
+            return_code = xmyshell_raw_command(cmd_line)
+            if return_code is None:
+                pyerror(f"'{cmd_line}' cannot be used in a pipeline with '|>'")
+                return -1
+            assert proc.stdin
+            proc.stdin.close()
+            sys.stdout = old_stdout
+            if target_var:
+                result, _ = proc.communicate()
+                namespace[target_var] = result
+                return proc.returncode
+            else:
+                return proc.wait()
 
     if target_var:
         from io import StringIO
@@ -310,21 +323,31 @@ def xmyshell(cmd_line: str) -> int:
             try:
                 target_dir = os.path.expanduser(target_dir)
                 # only works on Windows
-                if os.name == "nt" and target_dir.startswith("/"):
-                    import re
-
+                if os.name == "nt":
                     if target_dir.startswith("/"):
-                        m = re.match(r"^/([a-zA-Z])/", target_dir)
+                        m = re.match(r"^/([a-zA-Z])(/.*)?$", target_dir)
                         if m:
                             drive = m.group(1).upper()
-                            target_dir = drive + ":/" + target_dir[3:]
-                os.chdir(target_dir)
+                            rest = m.group(2) or ""
+                            target_dir = drive + ":" + rest
+                    target_dir = target_dir.replace("\\", "/")
+                _splited = shlex.split(target_dir)
+                if len(_splited) > 1:
+                    pyerror("too many arguments")
+                    return -1
+                os.chdir(_splited[0])
                 return 0
             except FileNotFoundError:
-                pyerror(f"file not found: '{target_dir}'")
+                pyerror(f"file not found: {target_dir!r}")
                 return -1
             except NotADirectoryError:
-                pyerror(f"not a directory: '{target_dir}'")
+                pyerror(f"not a directory: {target_dir!r}")
+                return -1
+            except PermissionError:
+                pyerror(f"permission denied: {target_dir!r}")
+                return -1
+            except (OSError, ValueError):
+                pyerror(f"wrong path format: {target_dir!r}")
                 return -1
 
         case "source":
@@ -342,10 +365,10 @@ def xmyshell(cmd_line: str) -> int:
         cmd_line = _fix_first_word(cmd_line)
     if target_var:
         result = _run(
-            cmd_line, shell=True, env=os.environ, capture_output=True, text=True
+            cmd_line, env=os.environ, capture_output=True, text=True
         )
         namespace[target_var] = result.stdout
     else:
-        result = _run(cmd_line, shell=True, env=os.environ)
+        result = _run(cmd_line, env=os.environ)
 
     return result.returncode

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/keybindings.py

@@ -3,7 +3,6 @@ from prompt_toolkit.buffer import Buffer
 from prompt_toolkit.key_binding import KeyBindings, KeyPressEvent
 from prompt_toolkit.selection import SelectionState
 from prompt_toolkit.keys import Keys
-from prompt_toolkit.key_binding.bindings.auto_suggest import load_auto_suggest_bindings
 from dataclasses import dataclass
 
 @dataclass
@@ -200,15 +199,12 @@ def _(event: KeyPressEvent) -> None:
         stack.pop()
         _auto_editing = False
         return
-    if should_completion(buffer) and (
-        len(buffer.text) > 0
-        and buffer.cursor_position > 0
-        and (
-            buffer.text[buffer.cursor_position - 1] in r"!@#$%^&*:;,./?|\+-=~()[]{}<>_"
-            or buffer.text[buffer.cursor_position - 1].isspace()
-        )
-        or buffer.cursor_position == 0
-    ):
+    pos = buffer.cursor_position
+    text = buffer.text
+    before_ok = pos == 0 or (pos > 0 and (text[pos - 1].isspace()
+            or text[pos - 1] in set(r"!@#$%^&*:;,./?|+-=~()[]{}<>_")))
+    not_on_quote = pos >= len(text) or text[pos] != '"'
+    if should_completion(buffer) and before_ok and not_on_quote:
         _auto_editing = True
         buffer.insert_text('""')
         buffer.cursor_left()
@@ -359,3 +355,18 @@ def _(event: KeyPressEvent) -> None:
     _auto_editing = False
     _last_info = BufferInfo.from_buffer(buffer)
     _reset_undo_merge()
+
+@bindings.add(Keys.Tab)
+def _(event: KeyPressEvent) -> None:
+    buffer = event.current_buffer
+    if buffer.complete_state:
+        if buffer.complete_state.current_completion is None:
+            buffer.complete_next()
+        if buffer.complete_state.current_completion:
+            # Trailing space bypasses prompt_toolkit's `completion_does_nothing`
+            # filter (which hides completions identical to the replaced text) and
+            # doubles as the shell argument separator. Invisible characters would
+            # also bypass the filter, but would corrupt command parsing.
+            text = buffer.complete_state.current_completion.text
+            buffer.complete_state.current_completion.text = text.rstrip()
+            buffer.apply_completion(buffer.complete_state.current_completion)

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/lexer.py

@@ -14,6 +14,46 @@ def _is_number_literal(s: str) -> bool:
     except (ValueError, SyntaxError):
         return False
 
+def _shell_split_keep_sep(text: str) -> list[str]:
+    parts: list[str] = []
+    quote: str | None = None
+    i = 0
+    n = len(text)
+    seg_start = 0
+
+    def flush(end: int) -> None:
+        nonlocal seg_start
+        if end > seg_start:
+            parts.append(text[seg_start:end])
+        seg_start = end
+
+    while i < n:
+        ch = text[i]
+        if quote is None:
+            if ch in " \t":
+                flush(i)
+                j = i
+                while j < n and text[j] in " \t":
+                    j += 1
+                parts.append(text[i:j])
+                seg_start = j
+                i = j
+                continue
+            elif ch == "\\" and i + 1 < n:
+                i += 2
+                continue
+            elif ch in ("'", '"'):
+                quote = ch
+        else:
+            if ch == quote:
+                quote = None
+            elif ch == "\\" and quote == '"' and i + 1 < n:
+                i += 2
+                continue
+        i += 1
+    flush(n)
+    return parts
+
 def _split_with_braces_and_pipes(line: str) -> list[str]:
     parts = []
     outer_buf = []
@@ -86,7 +126,7 @@ def _split_with_braces_and_pipes(line: str) -> list[str]:
     return parts
 
 def _lex_cmd(cmd: str, first_word: bool = True) -> list[tuple[str, str]]:
-    parts: list[str] = re.split(r"(\s+)", cmd)
+    parts: list[str] = _shell_split_keep_sep(cmd)
     result: list[tuple[str, str]] = []
     for part in parts:
         if part == "":

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/main.py

@@ -17,8 +17,9 @@ from .lexer import XmyShellLexer
 def xmyshell_main() -> None:
     xmyshell_init()
 
-    print(WELCOME_MESSAGE)
-    print(f"Initialized with {(time_ns() - _start_time) // 1_000_000}ms.")
+    if namespace.get("SHOW_WELCOME"):
+        print(WELCOME_MESSAGE)
+        print(f"Initialized with {(time_ns() - _start_time) // 1_000_000}ms.")
 
     session = PromptSession(
         history=FileHistory(os.path.expanduser("~/.xmyshell/history.txt")),

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/meta.py

@@ -59,6 +59,8 @@ Built-in variables:
   exec_duration   -  The duration which last command took.
   HOME_DIR        -  The home directory, similar to "~".
   PROFILE         -  The path of config file.
+  SHOW_WELCOME    -  Toggle whether to show welcome message.
+  SHELL_CMD       -  Shell command line prefix, e.g. ["cmd", "/c"]
 
 Keyboard Shortcuts:
   ↑↓      -  Navigate through command history.

{xmyshell-0.2.11 → xmyshell-0.2.13}/xmyshell/stubs/__init__.pyi

@@ -7,6 +7,8 @@ def basename(p: str) -> str: ...
 def cat(file_path: str) -> str: ...
 def alias(altname: str, target: str) -> None: ...
 def unalias(altname: str) -> None: ...
+SHOW_WELCOME: bool
+SHELL_CMD: list[str]
 HOME_DIR: str
 PROFILE: str
 exit_code: int

{xmyshell-0.2.11 → xmyshell-0.2.13/xmyshell.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xmyshell
-Version: 0.2.11
+Version: 0.2.13
 Summary: XmyShell is a shell-like tool built on top of prompt_toolkit which provides a persistent Python runtime.
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
@@ -163,6 +163,12 @@ The exit code of the last command.
 - `exec_duration`
 The duration which last command took.
 
+- `SHOW_WELCOME`
+Toggle whether to show welcome message when staring.
+
+- `SHELL_CMD`
+Shell command line prefix, defaults to `["cmd", "/c"]` on Windows and `["bin/sh", "-c"]` on other OS.
+
 - `HOME_DIR`
 The home directory, similar to `~`.