envstack 0.8.2__tar.gz → 0.8.3__tar.gz

{envstack-0.8.2/lib/envstack.egg-info → envstack-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.8.2
+Version: 0.8.3
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -277,6 +277,19 @@ BIZ=foo
 FOO=foo
 ```
 
+Here is an example using nested variable expansion:
+
+```yaml
+FOO: ${BIZ:=${BAR:=${BAZ:=baz}}}
+```
+
+Resolves to:
+
+```bash
+$ envstack -r
+FOO=baz
+```
+
 #### Includes
 
 Environment stack files can include other namespaced environments (you should

{envstack-0.8.2 → envstack-0.8.3}/README.md

@@ -253,6 +253,19 @@ BIZ=foo
 FOO=foo
 ```
 
+Here is an example using nested variable expansion:
+
+```yaml
+FOO: ${BIZ:=${BAR:=${BAZ:=baz}}}
+```
+
+Resolves to:
+
+```bash
+$ envstack -r
+FOO=baz
+```
+
 #### Includes
 
 Environment stack files can include other namespaced environments (you should

{envstack-0.8.2 → envstack-0.8.3}/lib/envstack/__init__.py

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

{envstack-0.8.2 → envstack-0.8.3}/lib/envstack/util.py

@@ -49,14 +49,14 @@ from envstack.node import AESGCMNode, Base64Node, EncryptedNode, FernetNode
 # value for unresolvable variables
 null = ""
 
+# regular expression pattern for matching windows drive letters
+drive_letter_pattern = re.compile(r"(?P<sep>[:;])?(?P<drive>[A-Z]:[/\\])")
+
 # regular expression pattern for bash-like variable expansion
 variable_pattern = re.compile(
-    r"\$\{([a-zA-Z_][a-zA-Z0-9_]*)(?::([=?])(\$\{[^}]*\}[\-\w/]*|[^}]*))?\}"
+    r"\$\{([a-zA-Z_][a-zA-Z0-9_]*)(?::([=?])((?:\$\{[^}]+\}|[^}])*))?\}"
 )
 
-# regular expression pattern for matching windows drive letters
-drive_letter_pattern = re.compile(r"(?P<sep>[:;])?(?P<drive>[A-Z]:[/\\])")
-
 
 def clear_sys_path(var: str = "PYTHONPATH"):
     """
@@ -72,9 +72,9 @@ def clear_sys_path(var: str = "PYTHONPATH"):
 def decode_value(value: str):
     """Returns a decoded value that's been encoded by a wrapper.
 
-    Decoding encoded environments can be tricky. For example, it must account for path
-    templates that include curly braces, e.g. path templates string like this must be
-    preserved:
+    Decoding encoded environments can be tricky. For example, it must account
+    for path templates that include curly braces, e.g. path templates string
+    like this must be preserved:
 
         '/path/with/{variable}'
 
@@ -270,6 +270,16 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         error message.
     """
 
+    def sanitize_value(value):
+        """Sanitize the value before returning it."""
+        # HACK: remove trailing curly braces if they exist
+        if type(value) is str and value.endswith("}") and not value.startswith("${"):
+            return value.rstrip("}")
+        # sanitize path-like values
+        elif type(value) is str and ":" in value and ("/" in value or "\\" in value):
+            return dedupe_paths(value)
+        return value
+
     def substitute_variable(match):
         """Substitute a variable match with its value."""
         var_name = match.group(1)
@@ -311,19 +321,10 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         # substitute all matches in the expression
         result = variable_pattern.sub(substitute_variable, expression)
 
-        # HACK: remove trailing curly braces if they exist
-        if result.endswith("}") and not result.startswith("${"):
-            result = result.rstrip("}")
-
         # evaluate any remaining modifiers, eg. ${VAR:=${FOO:=bar}}
         if variable_pattern.search(result):
             result = evaluate_modifiers(result, environ)
 
-        # dedupe path-like values and resolve separators
-        # TODO: replace with regex pattern to detect path-like strings
-        elif ":" in result and ("/" in result or "\\" in result):
-            result = dedupe_paths(result)
-
     # detect recursion errors
     except RecursionError:
         raise CyclicalReference(f"Cyclical reference detected in {expression}")
@@ -340,27 +341,15 @@ def evaluate_modifiers(expression: str, environ: dict = os.environ):
         elif isinstance(expression, FernetNode):
             result = expression.resolve(env=environ)
         elif isinstance(expression, list):
-            result = [
-                (
-                    variable_pattern.sub(substitute_variable, str(v))
-                    if isinstance(v, str)
-                    else v
-                )
-                for v in expression
-            ]
+            result = [(evaluate_modifiers(v, environ)) for v in expression]
         elif isinstance(expression, dict):
             result = {
-                k: (
-                    variable_pattern.sub(substitute_variable, str(v))
-                    if isinstance(v, str)
-                    else v
-                )
-                for k, v in expression.items()
+                k: (evaluate_modifiers(v, environ)) for k, v in expression.items()
             }
         else:
             result = expression
 
-    return result
+    return sanitize_value(result)
 
 
 def load_sys_path(

{envstack-0.8.2 → envstack-0.8.3/lib/envstack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: envstack
-Version: 0.8.2
+Version: 0.8.3
 Summary: Stacked environment variable management system
 Home-page: http://github.com/rsgalloway/envstack
 Author: Ryan Galloway
@@ -277,6 +277,19 @@ BIZ=foo
 FOO=foo
 ```
 
+Here is an example using nested variable expansion:
+
+```yaml
+FOO: ${BIZ:=${BAR:=${BAZ:=baz}}}
+```
+
+Resolves to:
+
+```bash
+$ envstack -r
+FOO=baz
+```
+
 #### Includes
 
 Environment stack files can include other namespaced environments (you should

{envstack-0.8.2 → envstack-0.8.3}/setup.py

@@ -40,7 +40,7 @@ with open(os.path.join(here, "README.md")) as f:
 
 setup(
     name="envstack",
-    version="0.8.2",
+    version="0.8.3",
     description="Stacked environment variable management system",
     long_description=long_description,
     long_description_content_type="text/markdown",

{envstack-0.8.2 → envstack-0.8.3}/tests/test_cmds.py

@@ -799,8 +799,4 @@ class TestIssues(unittest.TestCase):
 
 
 if __name__ == "__main__":
-    # TODO: make tests_cmds.py cross-platform
-    if sys.platform == "linux":
-        unittest.main()
-    else:
-        print(f"platform not supported: {sys.platform}")
+    unittest.main()

{envstack-0.8.2 → envstack-0.8.3}/tests/test_env.py

@@ -348,10 +348,101 @@ class TestResolveEnviron(unittest.TestCase):
         """Tests expansion modifier with special chars."""
         from envstack.env import resolve_environ
 
+        # remove ENV and ROOT from the environment
+        if "FOO" in os.environ:
+            del os.environ["FOO"]
+        if "VAR" in os.environ:
+            del os.environ["VAR"]
         env = {"VAR": "${VAR:=${FOO:=/foo/bar}}"}
         resolved = resolve_environ(env)
         self.assertEqual(resolved["VAR"], "/foo/bar")
 
+    def test_deploy_root_two(self):
+        """Tests $DEPLOY_ROOT with two vars."""
+        from envstack.env import resolve_environ
+
+        # set ENV and ROOT in the environment
+        os.environ["ROOT"] = "/mnt/pipe"
+        os.environ["ENV"] = "dev"
+        env = {
+            "DEPLOY_ROOT": "${ROOT}/${ENV}}",
+            "ENV": "${ENV:=prod}",
+            "ROOT": "${ROOT:=/var/tmp}",
+        }
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["DEPLOY_ROOT"], "/mnt/pipe/dev")
+
+    def test_deploy_root_three(self):
+        """Tests $DEPLOY_ROOT with three vars."""
+        from envstack.env import resolve_environ
+
+        env_value = os.getenv("ENV", "prod")
+        env = {
+            "DEPLOY_ROOT": "${MOUNT}/${DRIVE}/${ENV}}",
+            "ENV": "${ENV:=prod}",
+            "MOUNT": "/mnt",
+            "DRIVE": "${DRIVE:=pipe}",
+        }
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["DEPLOY_ROOT"], f"/mnt/pipe/{env_value}")
+
+    def test_deploy_root_default_one(self):
+        """Tests $DEPLOY_ROOT with default value and one var."""
+        from envstack.env import resolve_environ
+
+        # remove DEPLOY_ROOT, ENV and ROOT from the environment
+        if "DEPLOY_ROOT" in os.environ:
+            del os.environ["DEPLOY_ROOT"]
+        if "ENV" in os.environ:
+            del os.environ["ENV"]
+        if "ROOT" in os.environ:
+            del os.environ["ROOT"]
+        env = {
+            "DEPLOY_ROOT": "${DEPLOY_ROOT:=${TMP}}",
+            "ENV": "${ENV:=prod}",
+            "ROOT": "${ROOT:=/var/tmp}",
+            "TMP": "${ROOT}/${ENV}",
+        }
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["DEPLOY_ROOT"], "/var/tmp/prod")
+
+    def test_deploy_root_default_two(self):
+        """Tests $DEPLOY_ROOT with default value and two vars."""
+        from envstack.env import resolve_environ
+
+        # remove DEPLOY_ROOT, ENV and ROOT from the environment
+        if "DEPLOY_ROOT" in os.environ:
+            del os.environ["DEPLOY_ROOT"]
+        if "ENV" in os.environ:
+            del os.environ["ENV"]
+        if "ROOT" in os.environ:
+            del os.environ["ROOT"]
+        env = {
+            "DEPLOY_ROOT": "${DEPLOY_ROOT:=${ROOT}/${ENV}}",
+            "ENV": "${ENV:=prod}",
+            "ROOT": "${ROOT:=/var/lib}",
+        }
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["DEPLOY_ROOT"], "/var/lib/prod")
+
+    def test_deploy_root_default_two_from_env(self):
+        """Tests $DEPLOY_ROOT with default value from env."""
+        from envstack.env import resolve_environ
+
+        # remove DEPLOY_ROOT, ENV and ROOT from the environment
+        if "ENV" in os.environ:
+            del os.environ["ENV"]
+        if "ROOT" in os.environ:
+            del os.environ["ROOT"]
+        os.environ["DEPLOY_ROOT"] = "/some/path/here"
+        env = {
+            "DEPLOY_ROOT": "${DEPLOY_ROOT:=${ROOT}/${ENV}}",
+            "ENV": "${ENV:=prod}",
+            "ROOT": "${ROOT:=/var/lib}",
+        }
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["DEPLOY_ROOT"], "/some/path/here")
+
     def test_expansion_modifier_deferred(self):
         """Tests expansion modifier with deferred value."""
         from envstack.env import resolve_environ
@@ -387,30 +478,29 @@ class TestResolveEnviron(unittest.TestCase):
         self.assertEqual(resolved["BAZ"], "")
         self.assertRaises(KeyError, lambda: resolved["QUX"])
 
-    # FIXME: these tests are not passing
-    # def test_recursive_list_dict(self):
-    #     """Tests resolving a recursive list dict environment."""
-    #     from envstack.env import resolve_environ
+    def test_recursive_list_dict(self):
+        """Tests resolving a recursive list dict environment."""
+        from envstack.env import resolve_environ
 
-    #     env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": [{"qux": "${BAR}"}]}
-    #     resolved = resolve_environ(env)
-    #     self.assertEqual(resolved["BAZ"], [{"qux": "foo"}])
+        env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": [{"qux": "${BAR}"}]}
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["BAZ"], [{"qux": "foo"}])
 
-    # def test_recursive_dict_list(self):
-    #     """Tests resolving a recursive dict list environment."""
-    #     from envstack.env import resolve_environ
+    def test_recursive_dict_list(self):
+        """Tests resolving a recursive dict list environment."""
+        from envstack.env import resolve_environ
 
-    #     env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": {"qux": ["${BAR}"]}}
-    #     resolved = resolve_environ(env)
-    #     self.assertEqual(resolved["BAZ"], {"qux": ["foo"]})
+        env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": {"qux": ["${BAR}"]}}
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["BAZ"], {"qux": ["foo"]})
 
-    # def test_recursive_list_list(self):
-    #     """Tests resolving a recursive list list environment."""
-    #     from envstack.env import resolve_environ
+    def test_recursive_list_list(self):
+        """Tests resolving a recursive list list environment."""
+        from envstack.env import resolve_environ
 
-    #     env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": [["${BAR}"]]}
-    #     resolved = resolve_environ(env)
-    #     self.assertEqual(resolved["BAZ"], [["foo"]])
+        env = {"FOO": "foo", "BAR": "${FOO}", "BAZ": [["${BAR}"]]}
+        resolved = resolve_environ(env)
+        self.assertEqual(resolved["BAZ"], [["foo"]])
 
 
 class TestBakeEnviron(unittest.TestCase):

{envstack-0.8.2 → envstack-0.8.3}/tests/test_util.py

@@ -210,6 +210,13 @@ class TestEvaluateModifiers(unittest.TestCase):
         result = evaluate_modifiers(expression, environ)
         self.assertEqual(result, "/foo/bar/baz")
 
+    def test_embedded_substitution_multiple_env(self):
+        """Test multiple embedded substitution with value from env."""
+        expression = "${VAR:=${FOO:=${BAR:=/foo/bar/baz}}}"
+        environ = {"FOO": "/a/b/c"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/a/b/c")
+
     def test_embedded_substitution_prefix(self):
         """Test embedded substitution with prefix."""
         expression = "${VAR:=default}/path"
@@ -224,19 +231,75 @@ class TestEvaluateModifiers(unittest.TestCase):
         result = evaluate_modifiers(expression, environ)
         self.assertEqual(result, "default/path")
 
-    def test_embedded_substitution_with_slash(self):
-        """Test embedded substitution with special char /."""
-        expression = "${VAR:=${FOO}/bar}}"
+    def test_embedded_substitution_default_one_var_dash(self):
+        """Test embedded substitution with one var default dash"""
+        expression = "${VAR:=${FOO}-bar}"
         environ = {"FOO": "foo"}
         result = evaluate_modifiers(expression, environ)
-        self.assertEqual(result, "foo/bar")
+        self.assertEqual(result, "foo-bar")
 
-    def test_embedded_substitution_with_hyphen(self):
-        """Test embedded substitution with special char -."""
-        expression = "${VAR:=${FOO}-bar}}"
+    def test_embedded_substitution_default_one_var_slash(self):
+        """Test embedded substitution with one var default slash"""
+        expression = "${VAR:=${FOO}/bar}"
         environ = {"FOO": "foo"}
         result = evaluate_modifiers(expression, environ)
-        self.assertEqual(result, "foo-bar")
+        self.assertEqual(result, "foo/bar")
+
+    def test_embedded_substitution_default_two_vars(self):
+        """Test embedded substitution with two var default."""
+        expression = "${VAR:=${FOO}/${BAR}}"
+        environ = {"FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "foo/bar")
+
+    def test_embedded_substitution_default_two_vars_alt_1(self):
+        """Test embedded substitution with two var default, alt 1."""
+        expression = "${VAR:=/${FOO}/${BAR:=bar}}"
+        environ = {"FOO": "foo", "BAR": "baz"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/baz")
+
+    def test_embedded_substitution_default_two_vars_alt_2(self):
+        """Test embedded substitution with two var default, alt 2."""
+        expression = "${VAR:=/${FOO}/${FOO}}"
+        environ = {"FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/foo")
+
+    def test_embedded_substitution_default_two_vars_alt_3(self):
+        """Test embedded substitution with two var default, alt 3."""
+        expression = "${VAR:=/${FOO}}/${FOO}"
+        environ = {"FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/foo")
+
+    def test_embedded_substitution_default_two_vars_alt_4(self):
+        """Test embedded substitution with two var default, alt 4."""
+        expression = "${VAR:=/${FOO}}/${BAR:=bar}"
+        environ = {"FOO": "foo", "BAR": "baz"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/baz")
+
+    def test_embedded_substitution_default_three_vars(self):
+        """Test embedded substitution with three vars."""
+        expression = "${VAR:=/${FOO}/${BAR}/${BAZ:=baz}}"
+        environ = {"FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/bar/baz")
+
+    def test_embedded_substitution_default_three_vars_alt_1(self):
+        """Test embedded substitution with three vars, atl 1."""
+        expression = "${VAR:=/${FOO}}/${BAR}/${BAZ:=baz}"
+        environ = {"FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/foo/bar/baz")
+
+    def test_embedded_substitution_default_two_vars_from_env(self):
+        """Test embedded substitution with default, value from environ."""
+        expression = "${VAR:=${FOO}/${BAR}}"
+        environ = {"VAR": "/env/value", "FOO": "foo", "BAR": "bar"}
+        result = evaluate_modifiers(expression, environ)
+        self.assertEqual(result, "/env/value")
 
 
 class TestUtils(unittest.TestCase):