Merge pull request #76 from rsgalloway/v0.9.2

Version 0.9.2

Author: rsgalloway

dist.json

@@ -9,11 +9,11 @@
             "source": "bin/*",
             "destination": "{DEPLOY_ROOT}/bin/%1"
         },
-        "envstack_completion": {
+        "bash_completion": {
             "source": "bin/envstack_completion.sh",
             "destination": "/etc/bash_completion.d/envstack"
         },
-        "lib-envstack": {
+        "lib": {
             "source": "lib/envstack",
             "destination": "{DEPLOY_ROOT}/lib/python/envstack"
         }

env/hello.env

@@ -1,5 +1,5 @@
 #!/usr/bin/env envstack
-include: [default]
+include: [dev]
 all: &all
   LOG_LEVEL: ${LOG_LEVEL:=INFO}
   PYEXE: /usr/bin/python

lib/envstack/__init__.py

@@ -34,6 +34,6 @@
 """
 
 __prog__ = "envstack"
-__version__ = "0.9.1"
+__version__ = "0.9.2"
 
 from envstack.env import clear, init, revert, save  # noqa: F401

lib/envstack/cli.py

@@ -147,12 +147,19 @@ def parse_args():
         action="version",
         version=f"envstack {__version__}",
     )
-    parser.add_argument(
+    group = parser.add_mutually_exclusive_group(required=False)
+    group.add_argument(
         "namespace",
         metavar="STACK",
         nargs="*",
         default=[config.DEFAULT_NAMESPACE],
-        help="the environment stacks to use (default '%s')" % config.DEFAULT_NAMESPACE,
+        help="the environment stacks to use",
+    )
+    group.add_argument(
+        "-b",
+        "--bare",
+        action="store_true",
+        help="create a bare environment",
     )
     encrypt_group = parser.add_argument_group("encryption options")
     encrypt_group.add_argument(
@@ -175,10 +182,11 @@ def parse_args():
         help="save the environment to an env file",
     )
     bake_group.add_argument(
+        "-d",
         "--depth",
         type=int,
         default=0,
-        help="depth of environment stack to bake",
+        help="depth of environment stack to bake (default: 0 = flatten)",
     )
     parser.add_argument_group(bake_group)
     export_group = parser.add_argument_group("export options")
@@ -208,12 +216,6 @@ def parse_args():
         metavar="KEY=VALUE",
         help="overlay KEY=VALUE pairs to envstack environments",
     )
-    parser.add_argument(
-        "-b",
-        "--bare",
-        action="store_true",
-        help="create a bare environment",
-    )
     parser.add_argument(
         "--scope",
         metavar="SCOPE",
@@ -244,7 +246,7 @@ def parse_args():
         "-q",
         "--quiet",
         action="store_true",
-        help="print values only",
+        help="print the value of an environment variable only (no key)",
     )
 
     args = parser.parse_args(args_before_dash)
@@ -287,7 +289,15 @@ def main():
                 for key, value in data.items():
                     print(f"{key}={value}")
 
-        elif args.set is not None:
+        elif args.clear:
+            from envstack.env import clear
+
+            print(clear(args.namespace, shell=config.SHELL))
+
+        elif args.export and args.resolve is None and args.set is None:
+            print(export(args.namespace, shell=config.SHELL, encrypt=args.encrypt))
+
+        elif args.set is not None and args.resolve is None:
             force_stdin = args.set == [] or args.set == ["-"]
             using_pipe = args.set == [] and not sys.stdin.isatty()
 
@@ -331,7 +341,7 @@ def main():
             if args.export:
                 print(export_env_to_shell(env))
             elif args.out:
-                Env(env).write(args.out)
+                env.write(args.out, depth=args.depth)
             else:
                 for key, val in env.items():
                     if args.quiet:
@@ -343,30 +353,58 @@ def main():
                     else:
                         print(f"{key}={val}")
 
-        elif args.out:
+        elif args.out and args.resolve is None:
             bake_environ(
                 args.namespace,
                 filename=args.out,
-                depth=args.depth or 0,
+                depth=args.depth,
                 encrypt=args.encrypt,
             )
 
         elif args.resolve is not None:
+            if args.depth:
+                print("error: --depth is not valid with --resolve")
+                return 2
             resolved = resolve_environ(
                 load_environ(args.namespace, platform=args.platform)
             )
-            keys = args.resolve or resolved.keys()
-            for key in sorted(str(k) for k in keys):
-                val = resolved.get(key)
-                if key in resolved:
-                    if args.quiet:
-                        if len(keys) > 1:
-                            print("error: --quiet requires exactly one KEY")
-                            return 2
+            if args.set:
+                resolved.update(_parse_keyvals(args.set))
+            if args.encrypt:
+                resolved = encrypt_environ(resolved)
+            if args.out:
+                if len(args.resolve) == 0:
+                    resolved.write(args.out, depth=0)
+                else:
+                    keys = args.resolve or resolved.keys()
+                    if args.set:
+                        keys = set(keys).union(_parse_keyvals(args.set).keys())
+                    env = Env({key: resolved[key] for key in keys})
+                    env.write(args.out, depth=0)
+            elif args.export:
+                if len(args.resolve) == 0:
+                    print(export_env_to_shell(resolved, shell=config.SHELL))
+                else:
+                    keys = args.resolve or resolved.keys()
+                    if args.set:
+                        keys = set(keys).union(_parse_keyvals(args.set).keys())
+                    env = Env({key: resolved[key] for key in keys})
+                    print(export_env_to_shell(env, shell=config.SHELL))
+            else:
+                keys = args.resolve or resolved.keys()
+                if args.set:
+                    keys = set(keys).union(_parse_keyvals(args.set).keys())
+                for key in sorted(str(k) for k in keys):
+                    val = resolved.get(key)
+                    if key in resolved:
+                        if args.quiet:
+                            if len(keys) > 1:
+                                print("error: --quiet requires exactly one KEY")
+                                return 2
+                            else:
+                                print(val)
                         else:
-                            print(val)
-                    else:
-                        print(f"{key}={val}")
+                            print(f"{key}={val}")
 
         elif args.trace is not None:
             if len(args.trace) == 0:
@@ -388,14 +426,6 @@ def main():
             for source in env.sources:
                 print(source.path)
 
-        elif args.clear:
-            from envstack.env import clear
-
-            print(clear(args.namespace, config.SHELL))
-
-        elif args.export:
-            print(export(args.namespace, config.SHELL))
-
         else:
             env = load_environ(
                 args.namespace, platform=args.platform, encrypt=args.encrypt

lib/envstack/env.py

@@ -114,7 +114,7 @@ def length(self):
         """Returns the char length of the path"""
         return len(self.path)
 
-    def load(self, platform=config.PLATFORM):
+    def load(self, platform: str = config.PLATFORM):
         """Reads .env from .path, and returns an Env class object"""
         if self.path and not self.data:
             self.data = load_file(self.path)
@@ -305,17 +305,12 @@ def bake(self, filename: str = None, depth: int = 0, encrypt: bool = False):
             >>> env.bake("baked.env")
 
         :param filename: path to save the baked environment.
-        :param depth: depth of source files to incldue (default: all).
-        :param encrypt: encrypt the values.
+        :param depth: depth of source files to include (optional).
+        :param encrypt: encrypt the values (optional).
         :returns: baked environment.
         """
-        # get the sources for the given environment
         sources = self.sources
-
-        # look for encryption keys in the environment
-        os.environ.update(get_keys_from_env(self))
-
-        # create a baked source
+        os.environ.update(get_keys_from_env(self))  # for encryption
         baked = Source(filename)
 
         def get_node_class(value):
@@ -327,35 +322,63 @@ def get_node_class(value):
                     return EncryptedNode
             return value.__class__
 
-        # merge the sources into the outfile
+        # track included files and seen keys
+        includes = []
+        seen_keys = set()
+
+        for source in sources[:depth]:
+            for key, value in source.data.items():
+                if isinstance(value, dict):
+                    for k, v in value.items():
+                        if k in self:
+                            v = self[k]
+                        node_class = get_node_class(v)
+                        seen_keys.add(k)
+                else:
+                    seen_keys.add(key)
+
+        current_depth = 0
         for source in sources[-depth:]:
             for key, value in source.data.items():
+                if key == "include" and current_depth <= depth:
+                    includes = value
+                    continue
                 if isinstance(value, dict):
                     for k, v in value.items():
+                        if k in self and key == "all":  # override only in "all"
+                            v = self[k]
                         node_class = get_node_class(v)
                         baked.data.setdefault(key, {})[k] = node_class(v)
+                        seen_keys.add(k)
                 else:
-                    node_class = get_node_class(value)
-                    baked.data[key] = node_class(value)
+                    baked.data[key] = get_node_class(value)(value)
+                    seen_keys.add(key)
+                current_depth += 1
+
+        # add/override with values from the current environment
+        for key, value in self.items():
+            if key == "STACK" or key in seen_keys:
+                continue
+            baked.data["all"][key] = get_node_class(value)(value)
 
         # clear includes if environment stack is fully baked
-        if depth <= 0:
+        if depth <= 0 or depth >= len(sources):
             baked.data["include"] = []
+        else:
+            baked.data["include"] = includes
 
-        # write the baked environment to the file
+        # create the baked environment from the baked source
+        baked_env = Env()
+        baked_env.load_source(baked)
         if filename:
             try:
                 baked.write()
             except Exception as err:
                 raise WriteError(f"Failed to write {filename}", err)
 
-        # create the baked environment from the baked source
-        baked_env = Env()
-        baked_env.load_source(baked)
-
         return baked_env
 
-    def write(self, filename: str = None):
+    def write(self, filename: str, depth: int = 0, encrypt: bool = False):
         """Writes the environment to an env file.
 
             >>> env = Env({"FOO": "${BAR}", "BAR": "bar"})
@@ -367,11 +390,13 @@ def write(self, filename: str = None):
             >>> env.write("encrypted.env")
 
         :param filename: path to save the baked environment.
+        :param depth: depth of source files to include (optional).
+        :param encrypt: encrypt the values (optional).
         :returns: Source object.
         """
         # the environment was loaded from one or more sources
         if self.sources:
-            baked = self.bake(filename)
+            baked = self.bake(filename, depth=depth, encrypt=encrypt)
             return baked.sources[0]
 
         # the environment was created from scratch
@@ -634,19 +659,21 @@ def export(
     name: str = config.DEFAULT_NAMESPACE,
     shell: str = config.SHELL,
     scope: str = None,
+    encrypt: bool = False,
 ):
     """Returns shell commands that can be sourced to set environment stack
     environment variables.
 
     Supported shells: bash, sh, tcsh, cmd, pwsh (see config.detect_shell()).
 
     :param name: stack namespace.
-    :param shell: name of shell (default: current shell).
-    :param scope: environment scope (default: cwd).
+    :param shell: name of shell (optional).
+    :param scope: environment scope (optional).
+    :param encrypt: encrypt the values (optional).
     :returns: shell commands as string.
     """
-    resolved_env = resolve_environ(load_environ(name, scope=scope))
-    return export_env_to_shell(resolved_env, shell)
+    env = load_environ(name, scope=scope, encrypt=encrypt)
+    return export_env_to_shell(env, shell)
 
 
 def save():
@@ -747,8 +774,8 @@ def bake_environ(
         $ envstack [STACK] -o <filename>
 
     :param name: stack namespace.
-    :param scope: environment scope (default: cwd).
-    :param depth: depth of source files to incldue (default: all).
+    :param scope: environment scope (optional).
+    :param depth: depth of source files to include (optional).
     :param filename: path to save the baked environment.
     :param encrypt: encrypt the values.
     :returns: baked environment.

setup.py

@@ -40,7 +40,7 @@
 
 setup(
     name="envstack",
-    version="0.9.1",
+    version="0.9.2",
     description="Stacked environment variable management system",
     long_description=long_description,
     long_description_content_type="text/markdown",