python-hcl2 7.1.0__tar.gz → 7.2.1__tar.gz

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/CHANGELOG.md

@@ -7,7 +7,26 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## \[Unreleased\]
 
-- Nothing yet
+- Nothing yet.
+
+## \[7.2.1\] - 2025-05-16
+
+### Fixed
+
+- More robust escaping for special characters. Thanks, @eranor ([#224](https://github.com/amplify-education/python-hcl2/pull/224))
+- Issue parsing interpolation string as an object key ([#232](https://github.com/amplify-education/python-hcl2/pull/232))
+
+## \[7.2.0\] - 2025-04-24
+
+### Added
+
+- Possibility to parse deeply nested interpolations (formerly a Limitation), Thanks again, @weaversam8 ([#223](https://github.com/amplify-education/python-hcl2/pull/223))
+
+### Fixed
+
+- Issue parsing ellipsis in a separate line within `for` expression ([#221](https://github.com/amplify-education/python-hcl2/pull/221))
+- Issue parsing inline expression as an object key; **see Limitations in README.md** ([#222](https://github.com/amplify-education/python-hcl2/pull/222))
+- Preserve literals of e-notation floats in parsing and reconstruction. Thanks, @eranor ([#226](https://github.com/amplify-education/python-hcl2/pull/226))
 
 ## \[7.1.0\] - 2025-04-10
 

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hcl2
-Version: 7.1.0
+Version: 7.2.1
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -114,20 +114,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/README.md

@@ -87,20 +87,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/hcl2/hcl2.lark

@@ -1,7 +1,7 @@
 start : body
 body : (new_line_or_comment? (attribute | block))* new_line_or_comment?
 attribute : identifier EQ expression
-block : identifier (identifier | STRING_LIT)* new_line_or_comment? "{" body "}"
+block : identifier (identifier | STRING_LIT | string_with_interpolation)* new_line_or_comment? "{" body "}"
 new_line_or_comment: ( NL_OR_COMMENT )+
 NL_OR_COMMENT: /\n[ \t]*/ | /#.*\n/ | /\/\/.*\n/ | /\/\*(.|\n)*?(\*\/)/
 
@@ -45,6 +45,7 @@ expr_term : LPAR new_line_or_comment? expression new_line_or_comment? RPAR
             | float_lit
             | int_lit
             | STRING_LIT
+            | string_with_interpolation
             | tuple
             | object
             | function_call
@@ -59,10 +60,10 @@ expr_term : LPAR new_line_or_comment? expression new_line_or_comment? RPAR
             | for_tuple_expr
             | for_object_expr
 
-STRING_LIT : "\"" (STRING_CHARS | INTERPOLATION)* "\""
-STRING_CHARS : /(?:(?!\${)([^"\\]|\\.))+/+ // any character except '"" unless inside a interpolation string
-NESTED_INTERPOLATION : "${" /[^}]+/ "}"
-INTERPOLATION : "${" (/(?:(?!\${)([^}]))+/ | NESTED_INTERPOLATION)+ "}"
+STRING_LIT : "\"" STRING_CHARS? "\""
+STRING_CHARS : /(?:(?!\${)([^"\\]|\\.|\$\$))+/ // any character except '"', including escaped $$
+string_with_interpolation: "\"" (STRING_CHARS)* interpolation_maybe_nested (STRING_CHARS | interpolation_maybe_nested)* "\""
+interpolation_maybe_nested: "${" expression "}"
 
 
 int_lit : NEGATIVE_DECIMAL? DECIMAL+ | NEGATIVE_DECIMAL+
@@ -75,8 +76,9 @@ EQ : /[ \t]*=(?!=|>)/
 
 tuple : "[" (new_line_or_comment* expression new_line_or_comment* ",")* (new_line_or_comment* expression)? new_line_or_comment* "]"
 object : "{" new_line_or_comment? (new_line_or_comment* (object_elem | (object_elem COMMA)) new_line_or_comment*)* "}"
-object_elem : LPAR? object_elem_key RPAR? ( EQ | COLON ) expression
-object_elem_key : float_lit | int_lit | identifier | STRING_LIT | object_elem_key_dot_accessor
+object_elem : object_elem_key ( EQ | COLON ) expression
+object_elem_key : float_lit | int_lit | identifier | STRING_LIT | object_elem_key_dot_accessor | object_elem_key_expression | string_with_interpolation
+object_elem_key_expression : LPAR expression RPAR
 object_elem_key_dot_accessor : identifier (DOT identifier)+
 
 heredoc_template : /<<(?P<heredoc>[a-zA-Z][a-zA-Z0-9._-]+)\n?(?:.|\n)*?\n\s*(?P=heredoc)\n/
@@ -98,7 +100,7 @@ full_splat : "[*]" (get_attr | index)*
 
 FOR_OBJECT_ARROW : "=>"
 !for_tuple_expr : "[" new_line_or_comment? for_intro new_line_or_comment? expression new_line_or_comment? for_cond? new_line_or_comment? "]"
-!for_object_expr : "{" new_line_or_comment? for_intro new_line_or_comment? expression FOR_OBJECT_ARROW new_line_or_comment? expression "..."? new_line_or_comment? for_cond? new_line_or_comment? "}"
+!for_object_expr : "{" new_line_or_comment? for_intro new_line_or_comment? expression FOR_OBJECT_ARROW new_line_or_comment? expression new_line_or_comment? "..."? new_line_or_comment? for_cond? new_line_or_comment? "}"
 !for_intro : "for" new_line_or_comment? identifier ("," identifier new_line_or_comment?)? new_line_or_comment? "in" new_line_or_comment? expression new_line_or_comment? ":" new_line_or_comment?
 !for_cond : "if" new_line_or_comment? expression
 

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/hcl2/reconstructor.py

@@ -260,6 +260,7 @@ class HCLReconstructor(Reconstructor):
                 Terminal("STRING_LIT"),
                 Terminal("DECIMAL"),
                 Terminal("NAME"),
+                Terminal("NEGATIVE_DECIMAL"),
             ]:
                 return True
 
@@ -352,11 +353,21 @@ class HCLReverseTransformer:
 
     @staticmethod
     def _escape_interpolated_str(interp_s: str) -> str:
-        # begin by doing basic JSON string escaping, to add backslashes
-        interp_s = json.dumps(interp_s)
-
+        if interp_s.strip().startswith('<<-') or interp_s.strip().startswith('<<'):
+            # For heredoc strings, preserve their format exactly
+            return reverse_quotes_within_interpolation(interp_s)
+        # Escape backslashes first (very important to do this first)
+        escaped = interp_s.replace('\\', '\\\\')
+        # Escape quotes
+        escaped = escaped.replace('"', '\\"')
+        # Escape control characters
+        escaped = escaped.replace('\n', '\\n')
+        escaped = escaped.replace('\r', '\\r')
+        escaped = escaped.replace('\t', '\\t')
+        escaped = escaped.replace('\b', '\\b')
+        escaped = escaped.replace('\f', '\\f')
         # find each interpolation within the string and remove the backslashes
-        interp_s = reverse_quotes_within_interpolation(interp_s)
+        interp_s = reverse_quotes_within_interpolation(f'"{escaped}"')
         return interp_s
 
     @staticmethod
@@ -412,10 +423,7 @@ class HCLReverseTransformer:
     def _is_block(self, value: Any) -> bool:
         if isinstance(value, dict):
             block_body = value
-            if (
-                START_LINE_KEY in block_body.keys()
-                or END_LINE_KEY in block_body.keys()
-            ):
+            if START_LINE_KEY in block_body.keys() or END_LINE_KEY in block_body.keys():
                 return True
 
             try:
@@ -520,7 +528,7 @@ class HCLReverseTransformer:
 
         return Tree(Token("RULE", "body"), children)
 
-    # pylint: disable=too-many-branches, too-many-return-statements
+    # pylint: disable=too-many-branches, too-many-return-statements too-many-statements
     def _transform_value_to_expr_term(self, value, level) -> Union[Token, Tree]:
         """Transforms a value from a dictionary into an "expr_term" (a value in HCL2)
 
@@ -611,6 +619,37 @@ class HCLReverseTransformer:
                 ],
             )
 
+        if isinstance(value, float):
+            value = str(value)
+            literal = []
+
+            if value[0] == "-":
+                # pop two first chars - minus and a digit
+                literal.append(Token("NEGATIVE_DECIMAL", value[:2]))
+                value = value[2:]
+
+            while value != "":
+                char = value[0]
+
+                if char == ".":
+                    # current char marks beginning of decimal part: pop all remaining chars and end the loop
+                    literal.append(Token("DOT", char))
+                    literal.extend(Token("DECIMAL", char) for char in value[1:])
+                    break
+
+                if char == "e":
+                    # current char marks beginning of e-notation: pop all remaining chars and end the loop
+                    literal.append(Token("EXP_MARK", value))
+                    break
+
+                literal.append(Token("DECIMAL", char))
+                value = value[1:]
+
+            return Tree(
+                Token("RULE", "expr_term"),
+                [Tree(Token("RULE", "float_lit"), literal)],
+            )
+
         # store strings as single literals
         if isinstance(value, str):
             # potentially unpack a complex syntax structure

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/hcl2/transformer.py

@@ -44,7 +44,10 @@ class DictTransformer(Transformer):
         super().__init__()
 
     def float_lit(self, args: List) -> float:
-        return float("".join([self.to_tf_inline(arg) for arg in args]))
+        value = "".join([self.to_tf_inline(arg) for arg in args])
+        if "e" in value:
+            return self.to_string_dollar(value)
+        return float(value)
 
     def int_lit(self, args: List) -> int:
         return int("".join([self.to_tf_inline(arg) for arg in args]))
@@ -98,21 +101,21 @@ class DictTransformer(Transformer):
     def object_elem(self, args: List) -> Dict:
         # This returns a dict with a single key/value pair to make it easier to merge these
         # into a bigger dict that is returned by the "object" function
-        if args[0] == Token("LPAR", "("):
-            key = self.strip_quotes(str(args[1].children[0]))
-            key = f"({key})"
-            key = self.to_string_dollar(key)
-            value = args[4]
-        else:
-            key = self.strip_quotes(str(args[0].children[0]))
-            value = args[2]
-
-        value = self.to_string_dollar(value)
+
+        key = str(args[0].children[0])
+        if not re.match(r".*?(\${).*}.*", key):
+            # do not strip quotes of a interpolation string
+            key = self.strip_quotes(key)
+
+        value = self.to_string_dollar(args[2])
         return {key: value}
 
     def object_elem_key_dot_accessor(self, args: List) -> str:
         return "".join(args)
 
+    def object_elem_key_expression(self, args: List) -> str:
+        return self.to_string_dollar("".join(args))
+
     def object(self, args: List) -> Dict:
         args = self.strip_new_line_tokens(args)
         result: Dict[str, Any] = {}
@@ -179,7 +182,9 @@ class DictTransformer(Transformer):
         return f"{args[0]} ? {args[1]} : {args[2]}"
 
     def binary_op(self, args: List) -> str:
-        return " ".join([self.to_tf_inline(arg) for arg in args])
+        return " ".join(
+            [self.unwrap_string_dollar(self.to_tf_inline(arg)) for arg in args]
+        )
 
     def unary_op(self, args: List) -> str:
         args = self.process_nulls(args)
@@ -306,21 +311,31 @@ class DictTransformer(Transformer):
         """
         return [arg for arg in args if arg != "\n" and arg is not Discard]
 
+    def is_string_dollar(self, value: str) -> bool:
+        if not isinstance(value, str):
+            return False
+        return value.startswith("${") and value.endswith("}")
+
     def to_string_dollar(self, value: Any) -> Any:
         """Wrap a string in ${ and }"""
-        if isinstance(value, str):
+        if not isinstance(value, str):
+            return value
             # if it's already wrapped, pass it unmodified
-            if value.startswith("${") and value.endswith("}"):
-                return value
+        if self.is_string_dollar(value):
+            return value
 
-            if value.startswith('"') and value.endswith('"'):
-                value = str(value)[1:-1]
-                return self.process_escape_sequences(value)
+        if value.startswith('"') and value.endswith('"'):
+            value = str(value)[1:-1]
+            return self.process_escape_sequences(value)
+
+        if self.is_type_keyword(value):
+            return value
 
-            if self.is_type_keyword(value):
-                return value
+        return f"${{{value}}}"
 
-            return f"${{{value}}}"
+    def unwrap_string_dollar(self, value: str):
+        if self.is_string_dollar(value):
+            return value[2:-1]
         return value
 
     def strip_quotes(self, value: Any) -> Any:

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/hcl2/version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '7.1.0'
-__version_tuple__ = version_tuple = (7, 1, 0)
+__version__ = version = '7.2.1'
+__version_tuple__ = version_tuple = (7, 2, 1)

{python_hcl2-7.1.0 → python_hcl2-7.2.1}/python_hcl2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-hcl2
-Version: 7.1.0
+Version: 7.2.1
 Summary: A parser for HCL2
 Author-email: Amplify Education <github@amplify.com>
 License: MIT
@@ -114,20 +114,15 @@ We’ll try to answer any PR’s promptly.
 
 ## Limitations
 
-### Error parsing string interpolations nested more than 2 times
+### Using inline expression as an object key
 
-- Parsing following example is expected to throw out an exception and fail:
+- Object key can be an expression as long as it is wrapped in parentheses:
   ```terraform
   locals {
-    foo = "foo"
-    name = "prefix1-${"prefix2-${"${local.foo}-bar"}"}" //should interpolate into "prefix1-prefix2-foo-bar" but fails
-  }
-  ```
-  We recommend working around this by modifying the configuration in the following manner:
-  ```terraform
-  locals {
-    foo = "foo"
-    foo_bar = "${local.foo}-bar"
-    name = "prefix1-${"prefix2-${local.foo_bar}"}" //interpolates into "prefix1-prefix2-foo-bar"
+    foo = "bar"
+    baz = {
+      (format("key_prefix_%s", local.foo)) : "value"
+      # format("key_prefix_%s", local.foo) : "value" this will fail
+    }
   }
   ```