batch of changes

Author: kkozik-amplify

hcl2/parser.py

@@ -12,7 +12,7 @@
 def parser() -> Lark:
     """Build standard parser for transforming HCL2 text into python structures"""
     return Lark.open(
-        "rule_transformer/hcl2.lark.lark",
+        "rule_transformer/hcl2.lark",
         parser="lalr",
         cache=str(PARSER_FILE),  # Disable/Delete file to effect changes to the grammar
         rel_to=__file__,

hcl2/reconstructor.py

@@ -166,12 +166,17 @@ def _should_add_space(self, rule, current_terminal, is_block_label: bool = False
         if self._is_equals_sign(current_terminal):
             return True
 
+        if is_block_label:
+            pass
+            # print(rule, self._last_rule, current_terminal, self._last_terminal)
+
         if is_block_label and isinstance(rule, Token) and rule.value == "string":
             if (
                 current_terminal == self._last_terminal == Terminal("DBLQUOTE")
                 or current_terminal == Terminal("DBLQUOTE")
-                and self._last_terminal == Terminal("NAME")
+                and self._last_terminal == Terminal("IDENTIFIER")
             ):
+                # print("true")
                 return True
 
         # if we're in a ternary or binary operator, add space around the operator

hcl2/rule_transformer/deserializer.py

@@ -0,0 +1,31 @@
+import json
+from typing import Any, TextIO, List
+
+from hcl2.rule_transformer.rules.abstract import LarkElement, LarkRule
+from hcl2.rule_transformer.utils import DeserializationOptions
+
+
+class Deserializer:
+    def __init__(self, options=DeserializationOptions()):
+        self.options = options
+
+    def load_python(self, value: Any) -> LarkElement:
+        pass
+
+    def loads(self, value: str) -> LarkElement:
+        return self.load_python(json.loads(value))
+
+    def load(self, file: TextIO) -> LarkElement:
+        return self.loads(file.read())
+
+    def _deserialize(self, value: Any) -> LarkElement:
+        pass
+
+    def _deserialize_dict(self, value: dict) -> LarkRule:
+        pass
+
+    def _deserialize_list(self, value: List) -> LarkRule:
+        pass
+
+    def _deserialize_expression(self, value: str) -> LarkRule:
+        pass

hcl2/rule_transformer/hcl2.lark

@@ -11,11 +11,9 @@ IN : "in"
 FOR : "for"
 FOR_EACH : "for_each"
 
-// Identifiers and Names
-NAME : /[a-zA-Z_][a-zA-Z0-9_-]*/
-IDENTIFIER: NAME | IN | FOR | IF | FOR_EACH
 
 // Literals
+NAME : /[a-zA-Z_][a-zA-Z0-9_-]*/
 ESCAPED_INTERPOLATION.2: /\$\$\{[^}]*\}/
 STRING_CHARS.1: /(?:(?!\$\$\{)(?!\$\{)[^"\\]|\\.|(?:\$(?!\$?\{)))+/
 DECIMAL : "0".."9"
@@ -91,7 +89,8 @@ block : identifier (identifier | string)* new_line_or_comment? LBRACE body RBRAC
 new_line_or_comment: ( NL_OR_COMMENT )+
 
 // Basic literals and identifiers
-identifier: IDENTIFIER
+identifier : NAME
+keyword: IN | FOR | IF | FOR_EACH
 int_lit: INT_LITERAL
 float_lit: FLOAT_LITERAL
 string: DBLQUOTE string_part* DBLQUOTE
@@ -118,21 +117,20 @@ expr_term : LPAR new_line_or_comment? expression new_line_or_comment? RPAR
             | string
             | tuple
             | object
-            | function_call
-            | index_expr_term
-            | get_attr_expr_term
             | identifier
-            | provider_function_call
+            | function_call
             | heredoc_template
             | heredoc_template_trim
+            | index_expr_term
+            | get_attr_expr_term
             | attr_splat_expr_term
             | full_splat_expr_term
             | for_tuple_expr
             | for_object_expr
 
 // Collections
-tuple : LSQB (new_line_or_comment* expression new_line_or_comment* COMMA)* (new_line_or_comment* expression)? new_line_or_comment* RSQB
-object : LBRACE new_line_or_comment? (new_line_or_comment* (object_elem | (object_elem COMMA)) new_line_or_comment*)* RBRACE
+tuple : LSQB new_line_or_comment? (expression new_line_or_comment? COMMA new_line_or_comment?)* (expression new_line_or_comment? COMMA? new_line_or_comment?)?  RSQB
+object : LBRACE new_line_or_comment? ((object_elem | (object_elem new_line_or_comment? COMMA)) new_line_or_comment?)* RBRACE
 object_elem : object_elem_key ( EQ | COLON ) expression
 object_elem_key : float_lit | int_lit | identifier | string | object_elem_key_dot_accessor | object_elem_key_expression
 object_elem_key_expression : LPAR expression RPAR
@@ -143,9 +141,8 @@ heredoc_template : HEREDOC_TEMPLATE
 heredoc_template_trim : HEREDOC_TEMPLATE_TRIM
 
 // Functions
-function_call : identifier LPAR new_line_or_comment? arguments? new_line_or_comment? RPAR
-arguments : (expression (new_line_or_comment* COMMA new_line_or_comment*  expression)* (COMMA | ELLIPSIS)? new_line_or_comment*)
-provider_function_call: identifier COLONS identifier COLONS identifier LPAR new_line_or_comment? arguments? new_line_or_comment? RPAR
+function_call : identifier (COLONS identifier COLONS identifier)? LPAR new_line_or_comment? arguments? new_line_or_comment? RPAR
+arguments : (expression (new_line_or_comment? COMMA new_line_or_comment? expression)* (COMMA | ELLIPSIS)? new_line_or_comment?)
 
 // Indexing and attribute access
 index_expr_term : expr_term index
@@ -156,7 +153,7 @@ full_splat_expr_term : expr_term full_splat
 braces_index : LSQB new_line_or_comment? expression new_line_or_comment? RSQB
 short_index : DOT INT_LITERAL
 get_attr : DOT identifier
-attr_splat : ATTR_SPLAT get_attr*
+attr_splat : ATTR_SPLAT (get_attr | index)*
 full_splat : FULL_SPLAT_START (get_attr | index)*
 
 // For expressions

hcl2/rule_transformer/rules/abstract.py

@@ -2,15 +2,16 @@
 from typing import Any, Union, List, Optional, Tuple, Callable
 
 from lark import Token, Tree
+from lark.exceptions import VisitError
 from lark.tree import Meta
 
-from hcl2.rule_transformer.utils import SerializationOptions
+from hcl2.rule_transformer.utils import SerializationOptions, SerializationContext
 
 
 class LarkElement(ABC):
-    @property
+    @staticmethod
     @abstractmethod
-    def lark_name(self) -> str:
+    def lark_name() -> str:
         raise NotImplementedError()
 
     def __init__(self, index: int = -1, parent: "LarkElement" = None):
@@ -28,7 +29,9 @@ def to_lark(self) -> Any:
         raise NotImplementedError()
 
     @abstractmethod
-    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         raise NotImplementedError()
 
 
@@ -37,11 +40,6 @@ def __init__(self, value: Union[str, int]):
         self._value = value
         super().__init__()
 
-    @property
-    @abstractmethod
-    def lark_name(self) -> str:
-        raise NotImplementedError()
-
     @property
     @abstractmethod
     def serialize_conversion(self) -> Callable:
@@ -51,27 +49,26 @@ def serialize_conversion(self) -> Callable:
     def value(self):
         return self._value
 
-    def serialize(self, options: SerializationOptions = SerializationOptions()):
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         return self.serialize_conversion(self.value)
 
     def to_lark(self) -> Token:
-        return Token(self.lark_name, self.value)
+        return Token(self.lark_name(), self.value)
 
     def __str__(self) -> str:
         return str(self._value)
 
     def __repr__(self) -> str:
-        return f"<LarkToken instance: {self.lark_name} {self.value}>"
+        return f"<LarkToken instance: {self.lark_name()} {self.value}>"
 
 
 class LarkRule(LarkElement, ABC):
-    @property
-    @abstractmethod
-    def lark_name(self) -> str:
-        raise NotImplementedError()
-
     @abstractmethod
-    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         raise NotImplementedError()
 
     @property
@@ -94,7 +91,7 @@ def to_lark(self) -> Tree:
 
             result_children.append(child.to_lark())
 
-        return Tree(self.lark_name, result_children, meta=self._meta)
+        return Tree(self.lark_name(), result_children, meta=self._meta)
 
     def __init__(self, children: List[LarkElement], meta: Optional[Meta] = None):
         super().__init__()
@@ -103,6 +100,7 @@ def __init__(self, children: List[LarkElement], meta: Optional[Meta] = None):
 
         for index, child in enumerate(children):
             if child is not None:
+                print(child)
                 child.set_index(index)
                 child.set_parent(self)
 

hcl2/rule_transformer/rules/base.py

@@ -3,34 +3,37 @@
 
 from lark.tree import Meta
 
+from hcl2.dict_transformer import START_LINE, END_LINE
 from hcl2.rule_transformer.rules.abstract import LarkRule, LarkToken
-from hcl2.rule_transformer.rules.expression import Expression
-from hcl2.rule_transformer.rules.tokens import IdentifierToken, EQ_TOKEN
+from hcl2.rule_transformer.rules.expressions import ExpressionRule
+from hcl2.rule_transformer.rules.tokens import NAME, EQ
 
 from hcl2.rule_transformer.rules.whitespace import NewLineOrCommentRule
-from hcl2.rule_transformer.utils import SerializationOptions
+from hcl2.rule_transformer.utils import SerializationOptions, SerializationContext
 
 
 class AttributeRule(LarkRule):
     _children: Tuple[
-        IdentifierToken,
-        EQ_TOKEN,
-        Expression,
+        NAME,
+        EQ,
+        ExpressionRule,
     ]
 
-    @property
-    def lark_name(self) -> str:
+    @staticmethod
+    def lark_name() -> str:
         return "attribute"
 
     @property
-    def identifier(self) -> IdentifierToken:
+    def identifier(self) -> NAME:
         return self._children[0]
 
     @property
-    def expression(self) -> Expression:
+    def expression(self) -> ExpressionRule:
         return self._children[2]
 
-    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         return {self.identifier.serialize(options): self.expression.serialize(options)}
 
 
@@ -44,11 +47,13 @@ class BodyRule(LarkRule):
         ]
     ]
 
-    @property
-    def lark_name(self) -> str:
+    @staticmethod
+    def lark_name() -> str:
         return "body"
 
-    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         blocks: List[BlockRule] = []
         attributes: List[AttributeRule] = []
         comments = []
@@ -99,11 +104,13 @@ class StartRule(LarkRule):
     def body(self) -> BodyRule:
         return self._children[0]
 
-    @property
-    def lark_name(self) -> str:
+    @staticmethod
+    def lark_name() -> str:
         return "start"
 
-    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+    def serialize(
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         return self.body.serialize(options)
 
 
@@ -118,23 +125,31 @@ def __init__(self, children, meta: Optional[Meta] = None):
             child for child in children if not isinstance(child, LarkToken)
         ]
 
-    @property
-    def lark_name(self) -> str:
+    @staticmethod
+    def lark_name() -> str:
         return "block"
 
     @property
-    def labels(self) -> List[IdentifierToken]:
+    def labels(self) -> List[NAME]:
         return list(filter(lambda label: label is not None, self._labels))
 
     @property
     def body(self) -> BodyRule:
         return self._body
 
     def serialize(
-        self, options: SerializationOptions = SerializationOptions()
-    ) -> BodyRule:
+        self, options=SerializationOptions(), context=SerializationContext()
+    ) -> Any:
         result = self._body.serialize(options)
         labels = self._labels
-        for label in reversed(labels):
+        for label in reversed(labels[1:]):
             result = {label.serialize(options): result}
+
+        result.update(
+            {
+                START_LINE: self._meta.line,
+                END_LINE: self._meta.end_line,
+            }
+        )
+
         return result