envstack 0.9.3__tar.gz → 0.9.4__tar.gz

{envstack-0.9.3/lib/envstack.egg-info → envstack-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.9.3
+Version: 0.9.4
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -616,6 +616,7 @@ The following environment variables are used to help manage functionality:
 | DEFAULT_ENV_STACK | Name of the default environment stack (default) |
 | ENVPATH | Colon-separated paths to search for stack files |
 | IGNORE_MISSING | Ignore missing stack files when resolving environments |
+| INTERACTIVE | Run one-off commands in an interactive shell |
 | STACK | Stores the name of the current environment stack |
 
 # Tests

{envstack-0.9.3 → envstack-0.9.4}/README.md

@@ -592,6 +592,7 @@ The following environment variables are used to help manage functionality:
 | DEFAULT_ENV_STACK | Name of the default environment stack (default) |
 | ENVPATH | Colon-separated paths to search for stack files |
 | IGNORE_MISSING | Ignore missing stack files when resolving environments |
+| INTERACTIVE | Run one-off commands in an interactive shell |
 | STACK | Stores the name of the current environment stack |
 
 # Tests

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/__init__.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -34,6 +34,6 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "0.9.3"
+__version__ = "0.9.4"
 
 from envstack.env import clear, init, revert, save  # noqa: F401

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/cli.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -161,11 +161,6 @@ def parse_args():
         action="store_true",
         help="create a bare environment",
     )
-    parser.add_argument(
-        "--shell",
-        action="store_true",
-        help="drop into a shell with the environment loaded",
-    )
     encrypt_group = parser.add_argument_group("encryption options")
     encrypt_group.add_argument(
         "-e",
@@ -226,6 +221,12 @@ def parse_args():
         metavar="SCOPE",
         help="search scope for environment stack files",
     )
+    parser.add_argument(
+        "-u",
+        "--unresolved",
+        action="store_true",
+        help="dump unresolved environment variables to stdout",
+    )
     parser.add_argument(
         "-r",
         "--resolve",
@@ -263,11 +264,11 @@ def envshell(namespace: List[str] = None):
     """Run a shell in the given environment stack."""
     from .envshell import EnvshellWrapper
 
-    print("\U0001F680 Launching envshell... CTRL+D to exit")
+    print("\U0001F680 Launching envstack shell... CTRL+D to exit")
 
     name = (namespace or [config.DEFAULT_NAMESPACE])[:]
-    envshell = EnvshellWrapper(name)
-    return envshell.launch()
+    shell = EnvshellWrapper(name)
+    return shell.launch()
 
 
 def whichenv():
@@ -292,9 +293,6 @@ def main():
         if command:
             return run_command(command, args.namespace)
 
-        elif args.shell:
-            return envshell(args.namespace)
-
         elif args.keygen:
             from envstack.encrypt import generate_keys
 
@@ -445,13 +443,16 @@ def main():
             for source in env.sources:
                 print(source.path)
 
-        else:
+        elif args.unresolved:
             env = load_environ(
                 args.namespace, platform=args.platform, encrypt=args.encrypt
             )
             for k, v in sorted(env.items(), key=lambda x: str(x[0])):
                 print(f"{k}={v}")
 
+        else:
+            return envshell(args.namespace)
+
     except KeyboardInterrupt:
         print("Stopping...")
         return 2

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/config.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/encrypt.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/env.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/envshell.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -122,3 +122,22 @@ class EnvshellWrapper(Wrapper):
         Override to return argv list for subprocess.Popen(..., shell=False).
         """
         return _detect_shell_argv()
+
+    def get_shell_prompt(self) -> str:
+        """
+        Return the environment variable that controls the shell prompt and its
+        desired value.
+        """
+        if os.name == "nt":
+            return ("PROMPT", "$E[32m(${ENV:=${STACK}})$E[0m $P$G ")
+        else:
+            return ("PS1", "\[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ ")
+
+    def get_subprocess_env(self):
+        """
+        Override to inject PS1/PROMPT if not already set.
+        """
+        prompt_env, prompt_value = self.get_shell_prompt()
+        if prompt_env not in self.env:
+            self.env[prompt_env] = prompt_value
+        return super().get_subprocess_env()

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/exceptions.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/logger.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/node.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/path.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/util.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack/wrapper.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -37,7 +37,6 @@ import os
 import re
 import shlex
 import subprocess
-import sys
 import traceback
 
 from envstack import config, logger
@@ -93,6 +92,7 @@ class Wrapper(object):
 
         tool.log = MyLogger()
     """
+    shell: bool = False
 
     def __init__(self, namespace, args=[]):
         """Initializes the wrapper with the given namespace and args.
@@ -103,7 +103,7 @@ class Wrapper(object):
         super(Wrapper, self).__init__()
         self.args = args
         self.name = namespace
-        self.shell = True
+        self.shell = self.shell
         self.log = logger.log
         self.env = load_environ(namespace)
 
@@ -113,38 +113,34 @@ class Wrapper(object):
 
     def launch(self):
         """Launches the wrapped tool in a subprocess with env."""
-        exitcode = 0
         env = self.get_subprocess_env()
         command = self.get_subprocess_command(env)
 
         try:
-            process = subprocess.Popen(
-                args=command,
-                bufsize=0,
+            proc = subprocess.run(
+                command,
                 env=encode(env),
                 shell=self.shell,
+                check=False,
             )
+            return proc.returncode
         except Exception:
             traceback.print_exc()
-            exitcode = 1
-        else:
-            stdout, stderr = process.communicate()  # dead code, kept for reference
-            while stdout and stderr:
-                self.log.info(stdout)
-                self.log.error(stderr)
-            exitcode = process.poll()
-
-        return exitcode
+            return 1
 
     def get_subprocess_args(self, cmd):
         """Returns the arguments to be passed to the subprocess."""
         return self.args
 
     def get_subprocess_command(self, env):
-        """Returns the command to be passed to the subprocess."""
+        """Returns argv (preferred) or a command string if shell=True."""
         cmd = evaluate_modifiers(self.executable(), env)
         args = self.get_subprocess_args(cmd)
-        return " ".join([cmd] + args)
+
+        if self.shell:
+            return " ".join([cmd] + args)
+
+        return [cmd] + args
 
     def get_subprocess_env(self):
         """
@@ -173,52 +169,39 @@ class CommandWrapper(Wrapper):
         :param args: command and arguments as a list.
         """
         super(CommandWrapper, self).__init__(namespace, args)
-        self.cmd = args
+        self.cmd = list(args)
 
     def executable(self):
         """Returns the command to run."""
-        return config.SHELL
+        return self.cmd[0]
 
+    def get_subprocess_args(self, cmd):
+        return self.cmd[1:]
 
-class ShellWrapper(CommandWrapper):
-    """Wrapper class for running wrapped commands in bash, sh, or zsh."""
 
-    def __init__(self, namespace=config.DEFAULT_NAMESPACE, args=[]):
-        """
-        Initializes the command wrapper with the given namespace and args,
-        replacing the original command with the shell command, e.g.:
+class ShellWrapper(Wrapper):
+    """
+    Runs a *string expression* under the user's shell using -c.
+    Useful for wrapping shell expressions that need variable expansion:
 
-            >>> cmd = ShellWrapper(stack, ['ls', '-l'])
-            >>> print(cmd.executable())
-            bash
-            >>> print(cmd.args)
-            ['-i', '-c', 'ls -l']
+        >>> shell = ShellWrapper('default', 'echo {HOME}')
+    """
 
-        :param namespace: environment stack name (default: 'default').
-        :param args: command and arguments as a list.
-        :param interactive: run the command in an interactive shell (default: True).
-        """
-        super(ShellWrapper, self).__init__(namespace, args)
+    def __init__(self, namespace=config.DEFAULT_NAMESPACE, expr: str = ""):
+        super().__init__(namespace, args=[])
+        self.expr = expr
 
     def get_interactive(self, env: dict = os.environ):
-        """Returns whether to run the command in an interactive shell."""
         override = env.get("INTERACTIVE")
         if override is not None:
-            return override.lower() in {"1", "true", "yes", "on"}
-        return sys.stdin.isatty() and sys.stdout.isatty()
+            return str(override).lower() in {"1", "true", "yes", "on"}
+        return False  # default safe
 
     def get_subprocess_command(self, env: dict = os.environ):
-        """Returns the command to be passed to the shell in a subprocess."""
         interactive = self.get_interactive(env)
-        if re.search(r"\$\w+", self.cmd):
-            if interactive:
-                return f'{config.SHELL} -i -c "{self.cmd}"'
-            return f'{config.SHELL} -c "{self.cmd}"'
-        else:
-            escaped_command = shlex.quote(self.cmd)
-            if interactive:
-                return f"{config.SHELL} -i -c {escaped_command}"
-            return f"{config.SHELL} -c {escaped_command}"
+        if interactive:
+            return [config.SHELL, "-i", "-c", self.expr]
+        return [config.SHELL, "-c", self.expr]
 
     def executable(self):
         """Returns the shell command to run the original command."""
@@ -276,12 +259,34 @@ def run_command(command: str, namespace: str = config.DEFAULT_NAMESPACE):
     """
     logger.setup_stream_handler()
     shellname = os.path.basename(config.SHELL)
+
+    # normalize to argv list
+    argv = list(command) if isinstance(command, (list, tuple)) else to_args(command)
+
+    needs_shell = any(re.search(r"\{(\w+)\}", a) for a in argv)
+    if needs_shell:
+        expr_argv = [re.sub(r"\{(\w+)\}", r"${\1}", a) for a in argv]
+        expr = shell_join(expr_argv)
+        return ShellWrapper(namespace, expr).launch()
+
     if shellname in ["bash", "sh", "zsh"]:
-        command = re.sub(r"\{(\w+)\}", r"${\1}", shell_join(command))
-        cmd = ShellWrapper(namespace, command)
-    elif shellname in ["cmd"]:
-        command = re.sub(r"\{(\w+)\}", r"%\1%", " ".join(command))
-        cmd = CmdWrapper(namespace, command)
-    else:
-        cmd = CommandWrapper(namespace, command)
-    return cmd.launch()
+        # 1) if user explicitly invoked a shell (bash/sh/zsh), do not wrap again
+        if argv and os.path.basename(argv[0]) in ["bash", "sh", "zsh"]:
+            return CommandWrapper(namespace, argv).launch()
+
+        # 2) if command contains {VARS}, convert to ${VARS} and run as a shell expression
+        needs_shell = any(re.search(r"\{(\w+)\}", a) for a in argv)
+        if needs_shell:
+            expr_argv = [re.sub(r"\{(\w+)\}", r"${\1}", a) for a in argv]
+            expr = shell_join(expr_argv)
+            return ShellWrapper(namespace, expr).launch()
+
+        # 3) otherwise run direct argv (best behavior)
+        return CommandWrapper(namespace, argv).launch()
+
+    if shellname in ["cmd"]:
+        # windows behavior preserved (if you need it)
+        expr = re.sub(r"\{(\w+)\}", r"%\1%", " ".join(argv))
+        return CmdWrapper(namespace, expr).launch()
+
+    return CommandWrapper(namespace, argv).launch()

{envstack-0.9.3 → envstack-0.9.4/lib/envstack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.9.3
+Version: 0.9.4
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -616,6 +616,7 @@ The following environment variables are used to help manage functionality:
 | DEFAULT_ENV_STACK | Name of the default environment stack (default) |
 | ENVPATH | Colon-separated paths to search for stack files |
 | IGNORE_MISSING | Ignore missing stack files when resolving environments |
+| INTERACTIVE | Run one-off commands in an interactive shell |
 | STACK | Stores the name of the current environment stack |
 
 # Tests

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack.egg-info/SOURCES.txt

@@ -25,4 +25,5 @@ tests/test_cmds.py
 tests/test_encrypt.py
 tests/test_env.py
 tests/test_node.py
-tests/test_util.py
+tests/test_util.py
+tests/test_wrapper.py

{envstack-0.9.3 → envstack-0.9.4}/lib/envstack.egg-info/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
-envshell = envstack.cli:envshell
 envstack = envstack.cli:main
 whichenv = envstack.cli:whichenv

{envstack-0.9.3 → envstack-0.9.4}/setup.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -40,7 +40,7 @@ with open(os.path.join(here, "README.md")) as f:
 
 setup(
     name="envstack",
-    version="0.9.3",
+    version="0.9.4",
     description="Stacked environment variable management system",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -69,7 +69,6 @@ setup(
     entry_points={
         "console_scripts": [
             "envstack=envstack.cli:main",
-            "envshell=envstack.cli:envshell",
             "whichenv=envstack.cli:whichenv",
         ],
     },

{envstack-0.9.3 → envstack-0.9.4}/tests/test_cmds.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #
@@ -67,9 +67,7 @@ class TestUnresolved(unittest.TestCase):
     """Tests unresolved environment variables from the cli."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack -u"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -86,15 +84,14 @@ ENVPATH=${DEPLOY_ROOT}/env:${ENVPATH}
 HELLO=${HELLO:=world}
 LOG_LEVEL=${LOG_LEVEL:=INFO}
 PATH=${DEPLOY_ROOT}/bin:${PATH}
-PS1=\[\e[32m\](${ENV})\[\e[0m\] \w\$ 
+PS1=\[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ 
 PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 ROOT=%s
 STACK=default
 """
             % self.root
         )
-        command = self.envstack_bin
-        output = subprocess.check_output(command, shell=True, universal_newlines=True)
+        output = subprocess.check_output(self.envstack_bin, shell=True, universal_newlines=True)
         self.assertEqual(output, expected_output)
 
     def test_dev(self):
@@ -105,7 +102,7 @@ ENVPATH=${ROOT}/dev/env:${ROOT}/prod/env:${ENVPATH}
 HELLO=${HELLO:=world}
 LOG_LEVEL=DEBUG
 PATH=${ROOT}/dev/bin:${ROOT}/prod/bin:${PATH}
-PS1=\[\e[32m\](${ENV})\[\e[0m\] \w\$ 
+PS1=\[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ 
 PYTHONPATH=${ROOT}/dev/lib/python:${ROOT}/prod/lib/python:${PYTHONPATH}
 ROOT=%s
 STACK=dev
@@ -116,25 +113,6 @@ STACK=dev
         output = subprocess.check_output(command, shell=True, universal_newlines=True)
         self.assertEqual(output, expected_output)
 
-    def test_distman(self):
-        expected_output = (
-            """DEPLOY_ROOT=${ROOT}/${ENV}
-ENV=${ENV:=prod}
-ENVPATH=${DEPLOY_ROOT}/env:${ENVPATH}
-HELLO=${HELLO:=world}
-LOG_LEVEL=INFO
-PATH=${DEPLOY_ROOT}/bin:${PATH}
-PS1=\[\e[32m\](${ENV})\[\e[0m\] \w\$ 
-PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
-ROOT=%s
-STACK=distman
-"""
-            % self.root
-        )
-        command = "%s distman" % self.envstack_bin
-        output = subprocess.check_output(command, shell=True, universal_newlines=True)
-        self.assertEqual(output, expected_output)
-
     def test_hello(self):
         expected_output = (
             """DEPLOY_ROOT=${ROOT}/dev
@@ -167,7 +145,7 @@ INT=5
 LOG_LEVEL=${LOG_LEVEL:=INFO}
 NUMBER_LIST=[1, 2, 3]
 PATH=${DEPLOY_ROOT}/bin:${PATH}
-PS1=\[\e[32m\](${ENV})\[\e[0m\] \w\$ 
+PS1=\[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ 
 PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 ROOT=${HOME}/.local/pipe
 STACK=thing
@@ -181,9 +159,7 @@ class TestEncrypt(unittest.TestCase):
     """Tests encrypting environment variables from the cli."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack -u"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -208,7 +184,7 @@ ENVPATH=JHtERVBMT1lfUk9PVH0vZW52OiR7RU5WUEFUSH0=
 HELLO=JHtIRUxMTzo9d29ybGR9
 LOG_LEVEL=JHtMT0dfTEVWRUw6PUlORk99
 PATH=JHtERVBMT1lfUk9PVH0vYmluOiR7UEFUSH0=
-PS1=XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
+PS1=XFtcZVszMm1cXSgke0VOVjo9JHtTVEFDS319KVxbXGVbMG1cXSBcd1wkIA==
 PYTHONPATH=JHtERVBMT1lfUk9PVH0vbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 ROOT=L21udC9waXBl
 STACK=ZGVmYXVsdA==
@@ -257,7 +233,7 @@ ENVPATH=JHtST09UfS9kZXYvZW52OiR7Uk9PVH0vcHJvZC9lbnY6JHtFTlZQQVRIfQ==
 HELLO=JHtIRUxMTzo9d29ybGR9
 LOG_LEVEL=REVCVUc=
 PATH=JHtST09UfS9kZXYvYmluOiR7Uk9PVH0vcHJvZC9iaW46JHtQQVRIfQ==
-PS1=XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
+PS1=XFtcZVszMm1cXSgke0VOVjo9JHtTVEFDS319KVxbXGVbMG1cXSBcd1wkIA==
 PYTHONPATH=JHtST09UfS9kZXYvbGliL3B5dGhvbjoke1JPT1R9L3Byb2QvbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 ROOT=L21udC9waXBl
 STACK=ZGV2
@@ -278,9 +254,7 @@ class TestResolved(unittest.TestCase):
     """Tests resolved environment variables."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -310,15 +284,6 @@ STACK=dev
         output = subprocess.check_output(command, shell=True, universal_newlines=True)
         self.assertEqual(output, expected_output)
 
-    def test_distman(self):
-        expected_output = f"""DEPLOY_ROOT={self.root}/{os.getenv('ENV', 'prod')}
-ROOT={self.root}
-STACK=distman
-"""
-        command = "%s distman -r DEPLOY_ROOT ROOT STACK" % self.envstack_bin
-        output = subprocess.check_output(command, shell=True, universal_newlines=True)
-        self.assertEqual(output, expected_output)
-
     def test_dev_distman(self):
         expected_output = f"""DEPLOY_ROOT={self.root}/dev
 ROOT={self.root}
@@ -373,9 +338,7 @@ class TestBake(unittest.TestCase):
         self.filename = "baketest.env"
         if os.path.exists(self.filename):
             os.remove(self.filename)
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -408,15 +371,15 @@ all: &all
   PYTHONPATH: ${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 darwin:
   <<: *all
-  PS1: \[\e[32m\](${ENV})\[\e[0m\] \w\$ 
+  PS1: \[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ 
   ROOT: /Volumes/pipe
 linux:
   <<: *all
-  PS1: \[\e[32m\](${ENV})\[\e[0m\] \w\$ 
+  PS1: \[\e[32m\](${ENV:=${STACK}})\[\e[0m\] \w\$ 
   ROOT: /mnt/pipe
 windows:
   <<: *all
-  PROMPT: $E[32m(${ENV})$E[0m $P$G
+  PROMPT: $E[32m(${ENV:=${STACK}})$E[0m $P$G
   ROOT: //tools/pipe
 """
         output = subprocess.check_output(
@@ -499,15 +462,15 @@ all: &all
   PYTHONPATH: !encrypt JHtERVBMT1lfUk9PVH0vbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 darwin:
   <<: *all
-  PS1: !encrypt XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
+  PS1: !encrypt XFtcZVszMm1cXSgke0VOVjo9JHtTVEFDS319KVxbXGVbMG1cXSBcd1wkIA==
   ROOT: !encrypt L1ZvbHVtZXMvcGlwZQ==
 linux:
   <<: *all
-  PS1: !encrypt XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
+  PS1: !encrypt XFtcZVszMm1cXSgke0VOVjo9JHtTVEFDS319KVxbXGVbMG1cXSBcd1wkIA==
   ROOT: !encrypt L21udC9waXBl
 windows:
   <<: *all
-  PROMPT: !encrypt JEVbMzJtKCR7RU5WfSkkRVswbSAkUCRH
+  PROMPT: !encrypt JEVbMzJtKCR7RU5WOj0ke1NUQUNLfX0pJEVbMG0gJFAkRw==
   ROOT: !encrypt Ly90b29scy9waXBl
 """
         output = subprocess.check_output(
@@ -575,9 +538,7 @@ class TestCommands(unittest.TestCase):
     """Tests various envstack commands."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -639,9 +600,7 @@ class TestSet(unittest.TestCase):
 
     def setUp(self):
         self.filename = "settest.env"
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
@@ -762,9 +721,7 @@ class TestVarFlow(unittest.TestCase):
     """Tests the flow of environment variables through stacks."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         os.environ["ENVPATH"] = envpath
 
@@ -805,9 +762,7 @@ class TestDistman(unittest.TestCase):
     """Tests value for $DEPLOY_ROOT under various environment configurations."""
 
     def setUp(self):
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         self.python_cmd = """python -c \"import os,envstack;envstack.init('distman');print(os.getenv('DEPLOY_ROOT'))\""""
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
@@ -858,9 +813,7 @@ class TestDistman(unittest.TestCase):
 class TestIssues(unittest.TestCase):
     def setUp(self):
         self.root = create_test_root()
-        self.envstack_bin = os.path.join(
-            os.path.dirname(__file__), "..", "bin", "envstack"
-        )
+        self.envstack_bin = "envstack"
         os.environ["ENVPATH"] = os.path.join(self.root, "prod", "env")
 
     def tearDown(self):
@@ -988,7 +941,7 @@ class TestIssues(unittest.TestCase):
         cmd = [
             "bash",
             "-lc",
-            'envstack -- "echo hello from envstack"',
+            'envstack -- echo "hello from envstack"',
         ]
 
         proc = subprocess.Popen(

{envstack-0.9.3 → envstack-0.9.4}/tests/test_encrypt.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/tests/test_env.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/tests/test_node.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

{envstack-0.9.3 → envstack-0.9.4}/tests/test_util.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
 #

envstack-0.9.4/tests/test_wrapper.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+#
+# Copyright (c) 2024-2025, Ryan Galloway (ryan@rsgalloway.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  - Redistributions of source code must retain the above copyright notice,
+#    this list of conditions and the following disclaimer.
+#
+#  - Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+#  - Neither the name of the software nor the names of its contributors
+#    may be used to endorse or promote products derived from this software
+#    without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+__doc__ = """
+Contains unit tests for running commands.
+"""
+
+import os
+import pytest
+
+import envstack.wrapper as wrapper_mod
+from envstack.wrapper import Wrapper, CommandWrapper, run_command
+
+
+@pytest.fixture
+def stub_env(monkeypatch):
+    """
+    Make wrapper tests independent of real envstack stack files.
+
+    We monkeypatch load_environ(namespace) to return a deterministic env.
+    Adjust ROOT/ENV values as needed.
+    """
+    def _fake_load_environ(namespace):
+        # minimal env for tests; include PATH so subprocess can find tools
+        env = dict(os.environ)
+        env["ENV"] = namespace or "prod"
+        env["ROOT"] = "/tmp/envstack-root"
+        return env
+
+    monkeypatch.setattr(wrapper_mod, "load_environ", _fake_load_environ)
+    return _fake_load_environ
+
+
+class HelloWrapper(Wrapper):
+    """
+    Example wrapper that prints an env var passed as argv[0].
+    Uses shell=True because executable() returns a command-line string.
+    """
+    shell = True
+
+    def executable(self):
+        # prints env var named by first arg
+        return "python3 -c 'import os,sys;print(os.getenv(sys.argv[1]))'"
+
+
+def test_wrapper_shell_true_allows_command_string(stub_env, capfd):
+    """Test that Wrapper with shell=True runs command string."""
+    w = HelloWrapper("hello", ["ROOT"])
+    rc = w.launch()
+    out, err = capfd.readouterr()
+    assert rc == 0
+    assert out.strip() == "/tmp/envstack-root"
+
+
+def test_commandwrapper_runs_argv_without_shell(stub_env, capfd):
+    """Test that CommandWrapper runs argv mode without shell."""
+    w = CommandWrapper("hello", ["echo", "hi there"])
+    rc = w.launch()
+    out, err = capfd.readouterr()
+    assert rc == 0
+    assert out.strip() == "hi there"
+
+
+def test_run_command_preserves_quoted_arg_in_argv_mode(stub_env):
+    """Test that run_command preserves quoted args when shell=False."""
+    # Regression for: envstack -- bash -c "sleep 5" breaking into bash -c sleep 5
+    # Here we use something observable instead of sleep.
+    rc = run_command(["bash", "-c", "printf '%s\n' \"sleep 5\""], namespace="hello")
+    assert rc == 0
+
+
+def test_run_command_brace_expands_to_env_value(stub_env, capfd):
+    """Test that {VAR} in command args expands to env var value."""
+    rc = run_command(["echo", "{ROOT}"], namespace="hello")
+    out, err = capfd.readouterr()
+    assert rc == 0
+    assert out.strip() == "/tmp/envstack-root"
+
+
+def test_run_command_two_in_series_no_stop(stub_env, capfd):
+    """Test that two commands run in series without stopping the process."""
+    rc1 = run_command(["bash", "-c", "echo one"], namespace="hello")
+    rc2 = run_command(["bash", "-c", "echo two"], namespace="hello")
+    out, err = capfd.readouterr()
+    lines = [ln.strip() for ln in out.splitlines() if ln.strip()]
+    assert rc1 == 0 and rc2 == 0
+    assert lines[-2:] == ["one", "two"]
+
+
+@pytest.mark.parametrize(
+    "override, expected",
+    [
+        ("1", True),
+        ("true", True),
+        ("yes", True),
+        ("on", True),
+        ("0", False),
+        ("false", False),
+        ("no", False),
+        ("off", False),
+    ],
+)
+def test_interactive_env_override_parsing(stub_env, monkeypatch, override, expected):
+    env = dict(os.environ)
+    env["INTERACTIVE"] = override
+
+    # example: if you implemented ShellWrapper.get_interactive(env)
+    ShellWrapper = getattr(wrapper_mod, "ShellWrapper", None)
+    if ShellWrapper is None:
+        pytest.skip("ShellWrapper not present in envstack.wrapper")
+
+    sw = ShellWrapper("hello", "echo test")
+    assert sw.get_interactive(env) is expected