envstack 0.9.2__tar.gz → 0.9.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.9.2
+Version: 0.9.3
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -112,7 +112,9 @@ STACK=default
 If you are not seeing the above output, make sure the `default.env` stack file
 is in `${ENVPATH}` or the current working directory.
 
-> NOTE: The name of the current stack will always be stored in `${STACK}`
+> NOTE: The name of the current stack will always be stored in `${STACK}`.
+
+ENV is the tier, STACK is the namespace.
 
 Environments can be combined, or stacked, in order of priority (variables
 defined in stacks flow from higher scope to lower scope, left to right):
@@ -371,21 +373,21 @@ Then use `keys.env` to encrypt any other environment files:
 $ ./keys.env -- envstack -eo encrypted.env
 ```
 
-To decrypt, add `keys` to the env stack:
+To decrypt, run the command inside the `keys` environment again:
 
 ```bash
-$ envstack keys encrypted -r HELLO
+$ ./keys.env -- envstack encrypted -r HELLO
 HELLO=world
 ```
 
-Or run the command inside the `keys` environment like this:
+Or add `keys` to the env stack:
 
 ```bash
-$ ./keys.env -- envsatck encrypted -r HELLO
+$ envstack keys encrypted -r HELLO
 HELLO=world
 ```
 
-Or include `keys` in environments to automatically decrypt:
+Or automatically include `keys`:
 
 ```yaml
 include: [keys]

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

@@ -88,7 +88,9 @@ STACK=default
 If you are not seeing the above output, make sure the `default.env` stack file
 is in `${ENVPATH}` or the current working directory.
 
-> NOTE: The name of the current stack will always be stored in `${STACK}`
+> NOTE: The name of the current stack will always be stored in `${STACK}`.
+
+ENV is the tier, STACK is the namespace.
 
 Environments can be combined, or stacked, in order of priority (variables
 defined in stacks flow from higher scope to lower scope, left to right):
@@ -347,21 +349,21 @@ Then use `keys.env` to encrypt any other environment files:
 $ ./keys.env -- envstack -eo encrypted.env
 ```
 
-To decrypt, add `keys` to the env stack:
+To decrypt, run the command inside the `keys` environment again:
 
 ```bash
-$ envstack keys encrypted -r HELLO
+$ ./keys.env -- envstack encrypted -r HELLO
 HELLO=world
 ```
 
-Or run the command inside the `keys` environment like this:
+Or add `keys` to the env stack:
 
 ```bash
-$ ./keys.env -- envsatck encrypted -r HELLO
+$ envstack keys encrypted -r HELLO
 HELLO=world
 ```
 
-Or include `keys` in environments to automatically decrypt:
+Or automatically include `keys`:
 
 ```yaml
 include: [keys]

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

@@ -34,6 +34,6 @@ Stacked environment variable management system.
 """
 
 __prog__ = "envstack"
-__version__ = "0.9.2"
+__version__ = "0.9.3"
 
 from envstack.env import clear, init, revert, save  # noqa: F401

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

@@ -37,6 +37,7 @@ import argparse
 import re
 import sys
 import traceback
+from typing import List
 
 from envstack import __version__, config
 from envstack.env import (
@@ -147,20 +148,24 @@ def parse_args():
         action="version",
         version=f"envstack {__version__}",
     )
-    group = parser.add_mutually_exclusive_group(required=False)
-    group.add_argument(
+    parser.add_argument(
         "namespace",
         metavar="STACK",
         nargs="*",
         default=[config.DEFAULT_NAMESPACE],
         help="the environment stacks to use",
     )
-    group.add_argument(
+    parser.add_argument(
         "-b",
         "--bare",
         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",
@@ -254,9 +259,20 @@ def parse_args():
     return args, args_after_dash
 
 
+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")
+
+    name = (namespace or [config.DEFAULT_NAMESPACE])[:]
+    envshell = EnvshellWrapper(name)
+    return envshell.launch()
+
+
 def whichenv():
     """Entry point for the whichenv command line tool. Finds {VAR}s."""
-    from envstack.util import findenv
+    from .util import findenv
 
     if len(sys.argv) != 2:
         print("Usage: whichenv [VAR]")
@@ -276,6 +292,9 @@ 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
 

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

@@ -43,6 +43,7 @@ from envstack.logger import log
 
 # cryptography and _rust dependency may not be available everywhere
 # ImportError: DLL load failed while importing _rust: Module not found.
+Fernet = None
 try:
     import cryptography.exceptions
     from cryptography.fernet import Fernet, InvalidToken
@@ -50,7 +51,6 @@ try:
     from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
 except ImportError as err:
     log.debug("cryptography module not available: %s", err)
-    Fernet = None
 
 
 class Base64Encryptor(object):
@@ -78,7 +78,7 @@ class FernetEncryptor(object):
     KEY_VAR_NAME = "ENVSTACK_FERNET_KEY"
 
     def __init__(self, key: str = None, env: dict = os.environ):
-        if key:
+        if key and Fernet:
             self.key = Fernet(key)
         else:
             self.key = self.get_key(env)
@@ -90,7 +90,8 @@ class FernetEncryptor(object):
             key = Fernet.generate_key()
             return key.decode()
         else:
-            log.error("Fernet encryption not available")
+            log.debug("Fernet encryption not available")
+        return ""
 
     def get_key(self, env: dict = os.environ):
         """Load the encryption key from the environment `env`.
@@ -99,7 +100,7 @@ class FernetEncryptor(object):
         :return: encryption key.
         """
         key = env.get(self.KEY_VAR_NAME)
-        if key:
+        if key and Fernet:
             return Fernet(key)
         return key
 
@@ -313,12 +314,11 @@ def generate_keys():
 
     :returns: Dictionary containing Fernet and AES-GCM keys.
     """
-    from envstack.node import Base64Node
 
     symmetric_key = AESGCMEncryptor.generate_key()
     fernet_key = FernetEncryptor.generate_key()
 
     return {
-        AESGCMEncryptor.KEY_VAR_NAME: Base64Node(symmetric_key),
-        FernetEncryptor.KEY_VAR_NAME: Base64Node(fernet_key),
+        AESGCMEncryptor.KEY_VAR_NAME: symmetric_key,
+        FernetEncryptor.KEY_VAR_NAME: fernet_key,
     }

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

@@ -36,6 +36,7 @@ Contains functions and classes for processing scoped .env files.
 import os
 import re
 import string
+from collections import defaultdict
 from pathlib import Path
 
 import yaml  # noqa
@@ -77,7 +78,7 @@ class Source(object):
         :param path: path to .env file.
         """
         self.path = path
-        self.data = {}
+        self.data = defaultdict(dict)
 
     def __eq__(self, other):
         if not isinstance(other, Source):
@@ -126,7 +127,10 @@ class Source(object):
 
     def write(self, filepath: str = None):
         """Writes the source data to the .env file."""
-        util.dump_yaml(filepath or self.path, self.data)
+        try:
+            util.dump_yaml(filepath or self.path, self.data)
+        except Exception as err:
+            logger.log.exception("Failed to write %s: %s", filepath or self.path, err)
 
 
 class EnvVar(string.Template, str):

envstack-0.9.3/lib/envstack/envshell.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python
+#
+# 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.
+#
+
+"""
+Contains envshell wrapper class.
+
+Goal: drop the user into an interactive shell *without* sourcing their usual
+shell rc files, so prompt vars (PS1/PROMPT) set by envstack can survive.
+
+Notes:
+- You can override the detected shell with ENVSTACK_SHELL.
+  Examples:
+    ENVSTACK_SHELL=/bin/zsh envstack --shell
+    ENVSTACK_SHELL=pwsh envstack --shell
+"""
+
+import os
+from pathlib import Path
+from typing import List
+
+from . import config
+from .wrapper import Wrapper
+
+
+def _basename(p: str) -> str:
+    """Return the lowercase basename of a path, robustly."""
+    try:
+        return Path(p).name.lower()
+    except Exception:
+        return os.path.basename(p).lower()
+
+
+def _detect_shell_argv() -> List[str]:
+    """
+    Return argv list for a *clean* interactive shell.
+    """
+    shell = os.environ.get("ENVSTACK_SHELL", config.SHELL)
+
+    if os.name == "nt":
+        # Prefer COMSPEC if it looks like cmd.exe; otherwise allow pwsh/powershell.
+        comspec = os.environ.get("COMSPEC", "cmd.exe")
+
+        # If user explicitly asked for pwsh/powershell, honor it.
+        base = _basename(shell)
+        if base in ("pwsh", "pwsh.exe"):
+            return [shell, "-NoExit", "-NoProfile"]
+        if base in ("powershell", "powershell.exe"):
+            return [shell, "-NoExit", "-NoProfile"]
+
+        # Otherwise use cmd.exe, with /K to keep it open.
+        # (Even if config.SHELL returned "cmd", use COMSPEC so we get the real path.)
+        return [comspec, "/K"]
+
+    # POSIX shells
+    base = _basename(shell)
+
+    # bash: skip /etc/profile, ~/.bash_profile, ~/.bashrc, but stay interactive
+    if base == "bash":
+        return [shell, "--noprofile", "--norc", "-i"]
+
+    # zsh: -f skips zshrcs; -i for interactive
+    if base == "zsh":
+        return [shell, "-f", "-i"]
+
+    # tcsh/csh: -f skips rc; interactive by default when attached to a tty
+    if base in ("tcsh", "csh"):
+        return [shell, "-f"]
+
+    # fish: --no-config skips config.fish; interactive by default
+    if base == "fish":
+        return [shell, "--no-config"]
+
+    # Fallback: try interactive flag if common; otherwise just exec the shell
+    # (Most shells become interactive when connected to a tty anyway.)
+    return [shell, "-i"]
+
+
+class EnvshellWrapper(Wrapper):
+    """A wrapper that spawns an interactive shell with the environment set."""
+
+    def __init__(self, *args, **kwargs):
+        super(EnvshellWrapper, self).__init__(*args, **kwargs)
+        self.shell = False  # exec the shell directly
+
+    def executable(self):
+        """
+        Kept for interface compatibility. The actual argv is produced in
+        get_subprocess_command().
+        """
+        return ""
+
+    def get_subprocess_command(self, env):
+        """
+        Override to return argv list for subprocess.Popen(..., shell=False).
+        """
+        return _detect_shell_argv()

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

@@ -328,7 +328,7 @@ class CustomDumper(yaml.SafeDumper):
                 node.style = '"%s"' % node.value
             elif node.value and node.value[-1] == ":":
                 node.style = '"%s"' % node.value
-            elif ": " in node.value:
+            elif ": " in str(node.value):
                 node.style = '"%s"' % node.value
 
     def quote_vars(self, node: yaml.Node):

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

@@ -604,17 +604,12 @@ def validate_yaml(file_path: str):
 
     :param file_path: Path to the YAML file to validate.
     """
-    required_keys = {"all", "darwin", "linux", "windows"}
-
     try:
         with open(file_path, "r") as stream:
             data = yaml.safe_load(stream.read())
             # data = yaml.load(stream.read(), Loader=CustomLoader)
         if not isinstance(data, dict):
             raise yaml.YAMLError("invalid data structure")
-        missing_keys = required_keys - data.keys()
-        if missing_keys:
-            raise yaml.YAMLError(f"missing keys: {', '.join(sorted(missing_keys))}")
         return data
     except OSError as e:
         print(e)

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

@@ -128,7 +128,7 @@ class Wrapper(object):
             traceback.print_exc()
             exitcode = 1
         else:
-            stdout, stderr = process.communicate()
+            stdout, stderr = process.communicate()  # dead code, kept for reference
             while stdout and stderr:
                 self.log.info(stdout)
                 self.log.error(stderr)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.9.2
+Version: 0.9.3
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -112,7 +112,9 @@ STACK=default
 If you are not seeing the above output, make sure the `default.env` stack file
 is in `${ENVPATH}` or the current working directory.
 
-> NOTE: The name of the current stack will always be stored in `${STACK}`
+> NOTE: The name of the current stack will always be stored in `${STACK}`.
+
+ENV is the tier, STACK is the namespace.
 
 Environments can be combined, or stacked, in order of priority (variables
 defined in stacks flow from higher scope to lower scope, left to right):
@@ -371,21 +373,21 @@ Then use `keys.env` to encrypt any other environment files:
 $ ./keys.env -- envstack -eo encrypted.env
 ```
 
-To decrypt, add `keys` to the env stack:
+To decrypt, run the command inside the `keys` environment again:
 
 ```bash
-$ envstack keys encrypted -r HELLO
+$ ./keys.env -- envstack encrypted -r HELLO
 HELLO=world
 ```
 
-Or run the command inside the `keys` environment like this:
+Or add `keys` to the env stack:
 
 ```bash
-$ ./keys.env -- envsatck encrypted -r HELLO
+$ envstack keys encrypted -r HELLO
 HELLO=world
 ```
 
-Or include `keys` in environments to automatically decrypt:
+Or automatically include `keys`:
 
 ```yaml
 include: [keys]

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

@@ -7,6 +7,7 @@ lib/envstack/cli.py
 lib/envstack/config.py
 lib/envstack/encrypt.py
 lib/envstack/env.py
+lib/envstack/envshell.py
 lib/envstack/exceptions.py
 lib/envstack/logger.py
 lib/envstack/node.py

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

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

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

@@ -40,7 +40,7 @@ with open(os.path.join(here, "README.md")) as f:
 
 setup(
     name="envstack",
-    version="0.9.2",
+    version="0.9.3",
     description="Stacked environment variable management system",
     long_description=long_description,
     long_description_content_type="text/markdown",
@@ -69,6 +69,7 @@ setup(
     entry_points={
         "console_scripts": [
             "envstack=envstack.cli:main",
+            "envshell=envstack.cli:envshell",
             "whichenv=envstack.cli:whichenv",
         ],
     },

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

@@ -73,7 +73,7 @@ class TestUnresolved(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -86,6 +86,7 @@ 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\$ 
 PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 ROOT=%s
 STACK=default
@@ -104,6 +105,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\$ 
 PYTHONPATH=${ROOT}/dev/lib/python:${ROOT}/prod/lib/python:${PYTHONPATH}
 ROOT=%s
 STACK=dev
@@ -122,6 +124,7 @@ 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
@@ -140,6 +143,7 @@ ENVPATH=${ROOT}/dev/env:${ROOT}/prod/env:${ENVPATH}
 HELLO=${HELLO:=world}
 LOG_LEVEL=${LOG_LEVEL:=INFO}
 PATH=${ROOT}/dev/bin:${ROOT}/prod/bin:${PATH}
+PS1=\[\e[33m\](${STACK})\[\e[0m\] \w\$ 
 PYEXE=/usr/bin/python
 PYTHONPATH=${ROOT}/dev/lib/python:${ROOT}/prod/lib/python:${PYTHONPATH}
 ROOT=%s
@@ -163,6 +167,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\$ 
 PYTHONPATH=${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 ROOT=${HOME}/.local/pipe
 STACK=thing
@@ -182,7 +187,7 @@ class TestEncrypt(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -203,6 +208,7 @@ ENVPATH=JHtERVBMT1lfUk9PVH0vZW52OiR7RU5WUEFUSH0=
 HELLO=JHtIRUxMTzo9d29ybGR9
 LOG_LEVEL=JHtMT0dfTEVWRUw6PUlORk99
 PATH=JHtERVBMT1lfUk9PVH0vYmluOiR7UEFUSH0=
+PS1=XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
 PYTHONPATH=JHtERVBMT1lfUk9PVH0vbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 ROOT=L21udC9waXBl
 STACK=ZGVmYXVsdA==
@@ -251,6 +257,7 @@ ENVPATH=JHtST09UfS9kZXYvZW52OiR7Uk9PVH0vcHJvZC9lbnY6JHtFTlZQQVRIfQ==
 HELLO=JHtIRUxMTzo9d29ybGR9
 LOG_LEVEL=REVCVUc=
 PATH=JHtST09UfS9kZXYvYmluOiR7Uk9PVH0vcHJvZC9iaW46JHtQQVRIfQ==
+PS1=XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
 PYTHONPATH=JHtST09UfS9kZXYvbGliL3B5dGhvbjoke1JPT1R9L3Byb2QvbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 ROOT=L21udC9waXBl
 STACK=ZGV2
@@ -277,7 +284,7 @@ class TestResolved(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -321,14 +328,14 @@ STACK=distman
         output = subprocess.check_output(command, shell=True, universal_newlines=True)
         self.assertEqual(output, expected_output)
 
-    def test_test(self):
-        expected_output = f"""DEPLOY_ROOT={self.root}/test
+    def test_project(self):
+        expected_output = f"""DEPLOY_ROOT={self.root}/project
 HELLO=world
 ROOT={self.root}
-STACK=test
+STACK=project
 """
         command = (
-            "ENV=blah ROOT=/var/tmp %s test -r DEPLOY_ROOT HELLO ROOT STACK"
+            "ENV=blah ROOT=/var/tmp %s project -r DEPLOY_ROOT HELLO ROOT STACK"
             % self.envstack_bin
         )
         output = subprocess.check_output(command, shell=True, universal_newlines=True)
@@ -341,7 +348,7 @@ ROOT={self.root}
 STACK=foobar
 """
         command = (
-            "ENV=blah ROOT=/var/tmp %s test foobar -r DEPLOY_ROOT HELLO ROOT STACK"
+            "ENV=blah ROOT=/var/tmp %s project foobar -r DEPLOY_ROOT HELLO ROOT STACK"
             % self.envstack_bin
         )
         output = subprocess.check_output(command, shell=True, universal_newlines=True)
@@ -372,7 +379,7 @@ class TestBake(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -401,13 +408,16 @@ all: &all
   PYTHONPATH: ${DEPLOY_ROOT}/lib/python:${PYTHONPATH}
 darwin:
   <<: *all
+  PS1: \[\e[32m\](${ENV})\[\e[0m\] \w\$ 
   ROOT: /Volumes/pipe
 linux:
   <<: *all
+  PS1: \[\e[32m\](${ENV})\[\e[0m\] \w\$ 
   ROOT: /mnt/pipe
 windows:
   <<: *all
-  ROOT: X:/pipe
+  PROMPT: $E[32m(${ENV})$E[0m $P$G
+  ROOT: //tools/pipe
 """
         output = subprocess.check_output(
             command,
@@ -418,7 +428,7 @@ windows:
 
     def test_dev(self):
         """Tests baking the dev stack."""
-        command = make_command(self.envstack_bin, self.filename, "dev", "-d 1")
+        command = make_command(self.envstack_bin, self.filename, "dev", "-d", "1")
         expected_output = """#!/usr/bin/env envstack
 include: [default]
 all: &all
@@ -489,13 +499,16 @@ all: &all
   PYTHONPATH: !encrypt JHtERVBMT1lfUk9PVH0vbGliL3B5dGhvbjoke1BZVEhPTlBBVEh9
 darwin:
   <<: *all
+  PS1: !encrypt XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
   ROOT: !encrypt L1ZvbHVtZXMvcGlwZQ==
 linux:
   <<: *all
+  PS1: !encrypt XFtcZVszMm1cXSgke0VOVn0pXFtcZVswbVxdIFx3XCQg
   ROOT: !encrypt L21udC9waXBl
 windows:
   <<: *all
-  ROOT: !encrypt WDovcGlwZQ==
+  PROMPT: !encrypt JEVbMzJtKCR7RU5WfSkkRVswbSAkUCRH
+  ROOT: !encrypt Ly90b29scy9waXBl
 """
         output = subprocess.check_output(
             command,
@@ -568,7 +581,7 @@ class TestCommands(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -602,18 +615,18 @@ class TestCommands(unittest.TestCase):
         )
         self.assertEqual(output, expected_output)
 
-    def test_test_echo_deploy_root(self):
-        """Tests the test stack with an echo command."""
-        command = "%s test -- echo {DEPLOY_ROOT}" % self.envstack_bin
-        expected_output = f"{self.root}/test\n"
+    def test_project_echo_deploy_root(self):
+        """Tests the project stack with an echo command."""
+        command = "%s project -- echo {DEPLOY_ROOT}" % self.envstack_bin
+        expected_output = f"{self.root}/project\n"
         output = subprocess.check_output(
             command, start_new_session=True, shell=True, universal_newlines=True
         )
         self.assertEqual(output, expected_output)
 
-    def test_test_echo_deploy_root(self):
-        """Tests the test stack with an echo command."""
-        command = "%s test foobar -- echo {DEPLOY_ROOT}" % self.envstack_bin
+    def test_project_echo_deploy_root_foobar(self):
+        """Tests the project stack with an echo command."""
+        command = "%s project foobar -- echo {DEPLOY_ROOT}" % self.envstack_bin
         expected_output = f"{self.root}/foobar\n"
         output = subprocess.check_output(
             command, start_new_session=True, shell=True, universal_newlines=True
@@ -632,7 +645,7 @@ class TestSet(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -799,7 +812,7 @@ class TestDistman(unittest.TestCase):
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         self.root = {
             "linux": "/mnt/pipe",
-            "win32": "X:/pipe",
+            "win32": "//tools/pipe",
             "darwin": "/Volumes/pipe",
         }.get(sys.platform)
         os.environ["ENVPATH"] = envpath
@@ -823,15 +836,15 @@ class TestDistman(unittest.TestCase):
         self.assertEqual(output, expected_output)
 
     def test_test_deploy_root(self):
-        command = "ENV=invalid %s test -- %s" % (self.envstack_bin, self.python_cmd)
-        expected_output = f"{self.root}/test\n"
+        command = "ENV=invalid %s project -- %s" % (self.envstack_bin, self.python_cmd)
+        expected_output = f"{self.root}/project\n"
         output = subprocess.check_output(
             command, start_new_session=True, shell=True, universal_newlines=True
         )
         self.assertEqual(output, expected_output)
 
     def test_foobar_deploy_root(self):
-        command = "ENV=invalid %s test foobar -- %s" % (
+        command = "ENV=invalid %s project foobar -- %s" % (
             self.envstack_bin,
             self.python_cmd,
         )
@@ -922,7 +935,7 @@ class TestIssues(unittest.TestCase):
         env/dev.env:
             ENVPATH: ${ROOT}/dev/env:${ROOT}/prod/env:${ENVPATH}
 
-        env/test.env:
+        env/project.env:
             ENVPATH: ${ROOT}/${STACK}/env:${ROOT}/prod/env
         """
         from envstack.env import Env
@@ -950,11 +963,10 @@ class TestIssues(unittest.TestCase):
         )
         self.assertEqual(output, expected_output)
 
-        # test.env does use STACK in ENVPATH and should include our test env
-        command = "%s test test_issue_55 --sources" % self.envstack_bin
+        # project.env does use STACK in ENVPATH and should include our test env
+        command = "%s project test_issue_55 --sources" % self.envstack_bin
         expected_output = f"""{self.root}/prod/env/default.env
-{self.root}/prod/env/dev.env
-{self.root}/prod/env/test.env
+{self.root}/prod/env/project.env
 {self.root}/test_issue_55/env/test_issue_55.env
 """
         output = subprocess.check_output(

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

@@ -176,7 +176,7 @@ class TestEnv(unittest.TestCase):
         env = load_environ("thing")
         baked = env.bake()
         for k, v in env.items():
-            if k == "STACK":
+            if k == "STACK" or k == "PS1":  # skip
                 continue
             self.assertEqual(baked[k], v)
 
@@ -189,7 +189,7 @@ class TestEnv(unittest.TestCase):
         env1.write(self.filename, depth=0)
         env2 = load_environ(self.filename)
         for k, v in env1.items():
-            if k == "STACK":
+            if k == "STACK" or k == "PS1":  # skip
                 continue
             self.assertEqual(env2[k], v)
 
@@ -342,8 +342,8 @@ class TestInit(unittest.TestCase):
         self.assertEqual(diffs["removed"], {})
         self.assertEqual(diffs["unchanged"], original_env)
 
-    def test_init_zzz_custom(self):
-        """Tests init with custom test stack."""
+    def test_init_zzz_project(self):
+        """Tests init with custom project stack."""
         envpath = os.path.join(os.path.dirname(__file__), "..", "env")
         os.environ["ENVPATH"] = envpath
         os.environ["HELLO"] = "goodbye"
@@ -351,7 +351,7 @@ class TestInit(unittest.TestCase):
         original_env = os.environ.copy()
         sys_path = sys.path.copy()
 
-        envstack.init("test", "custom", ignore_missing=True)
+        envstack.init("project", "custom", ignore_missing=True)
         self.assertEqual(os.getenv("ENV"), "custom")
         self.assertEqual(os.getenv("STACK"), "custom")
         self.assertEqual(os.getenv("DEPLOY_ROOT"), f"{self.root}/custom")
@@ -667,7 +667,7 @@ class TestBakeEnviron(unittest.TestCase):
 
         # compare the values
         for key, value in env.items():
-            if key == "STACK":  # skip the stack name
+            if key == "STACK" or key == "PS1":  # skip
                 continue
             self.assertEqual(baked[key], value)
 
@@ -695,7 +695,7 @@ class TestBakeEnviron(unittest.TestCase):
 
         # compare the values
         for key, value in env.items():
-            if key == "STACK":
+            if key == "STACK" or key == "PS1":  # skip
                 continue
             self.assertEqual(baked2_reloaded[key], value)
 
@@ -1062,9 +1062,9 @@ class TestIssues(unittest.TestCase):
         # FIXME: why is this necessary? (think it's caching seen stacks)
         envstack.revert()
 
-        # load our test env file by loading the "test" env first, which
+        # load our project env file by loading the "project" env first, which
         # does use STACK in ENVPATH
-        env2 = load_environ(["test", "test_issue_55"])
+        env2 = load_environ(["project", "test_issue_55"])
 
         # last env file should be our test env file
         self.assertEqual(str(env2.sources[-1].path), test_env_file)

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

@@ -172,7 +172,7 @@ class TestTemplate(unittest.TestCase):
 class TestCustomLoader(unittest.TestCase):
     def test_construct_mapping(self):
         """test the CustomLoader construct_mapping method"""
-        envfile = os.path.join(envpath, "test.env")
+        envfile = os.path.join(envpath, "project.env")
         loader = CustomLoader(open(envfile, "r"))
         node = yaml.MappingNode("tag", [])
         mapping = loader.construct_mapping(node)