batch of different changes

Author: kkozik-amplify

hcl2/rule_transformer/rules/abstract.py

@@ -4,14 +4,16 @@
 from lark import Token, Tree
 from lark.tree import Meta
 
+from hcl2.rule_transformer.utils import SerializationOptions
+
 
 class LarkElement(ABC):
     @abstractmethod
-    def tree(self) -> Token:
+    def reverse(self) -> Any:
         raise NotImplementedError()
 
     @abstractmethod
-    def serialize(self) -> Any:
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
         raise NotImplementedError()
 
 
@@ -28,10 +30,10 @@ def name(self) -> str:
     def value(self):
         return self._value
 
-    def serialize(self) -> Any:
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
         return self._value
 
-    def tree(self) -> Token:
+    def reverse(self) -> Token:
         return Token(self.name, self.value)
 
     def __str__(self) -> str:
@@ -47,45 +49,45 @@ def __repr__(self) -> str:
 RPAR_TOKEN = LarkToken  # right parenthesis
 
 
-class TokenSequence:
+class TokenSequence(LarkElement):
     def __init__(self, tokens: List[LarkToken]):
         self.tokens = tokens
 
-    def tree(self) -> List[Token]:
-        return [token.tree() for token in self.tokens]
+    def reverse(self) -> List[Token]:
+        return [token.reverse() for token in self.tokens]
 
-    def joined(self):
+    def serialize(self, options: SerializationOptions = SerializationOptions()):
         return "".join(str(token) for token in self.tokens)
 
 
-class LarkRule(ABC):
+class LarkRule(LarkElement, ABC):
     @staticmethod
     @abstractmethod
     def rule_name() -> str:
         raise NotImplementedError()
 
     @abstractmethod
-    def serialize(self) -> Any:
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
         raise NotImplementedError()
 
     @property
     def children(self) -> List[LarkElement]:
         return self._children
 
-    def tree(self) -> Tree:
+    def reverse(self) -> Tree:
         result_children = []
         for child in self._children:
             if child is None:
                 continue
 
             if isinstance(child, TokenSequence):
-                result_children.extend(child.tree())
+                result_children.extend(child.reverse())
             else:
-                result_children.append(child.tree())
+                result_children.append(child.reverse())
 
-        return Tree(self.rule_name(), result_children)
+        return Tree(self.rule_name(), result_children, meta=self._meta)
 
-    def __init__(self, children, meta: Optional[Meta] = None):
+    def __init__(self, children: List, meta: Optional[Meta] = None):
         self._children = children
         self._meta = meta
 

hcl2/rule_transformer/rules/base.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from typing import Tuple, Any, List, Union, Optional
 
 from lark.tree import Meta
@@ -7,6 +8,7 @@
 from hcl2.rule_transformer.rules.token_sequence import IdentifierRule
 
 from hcl2.rule_transformer.rules.whitespace import NewLineOrCommentRule
+from hcl2.rule_transformer.utils import SerializationOptions
 
 
 class AttributeRule(LarkRule):
@@ -28,8 +30,8 @@ def identifier(self) -> IdentifierRule:
     def expression(self) -> Expression:
         return self._children[2]
 
-    def serialize(self) -> Any:
-        return {self.identifier.serialize(): self.expression.serialize()}
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+        return {self.identifier.serialize(options): self.expression.serialize(options)}
 
 
 class BodyRule(LarkRule):
@@ -46,34 +48,51 @@ class BodyRule(LarkRule):
     def rule_name() -> str:
         return "body"
 
-    def serialize(self) -> Any:
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
         blocks: List[BlockRule] = []
         attributes: List[AttributeRule] = []
         comments = []
-
+        inline_comments = []
         for child in self._children:
+
             if isinstance(child, BlockRule):
                 blocks.append(child)
+
             if isinstance(child, AttributeRule):
                 attributes.append(child)
+                # collect in-line comments from attribute assignments, expressions etc
+                inline_comments.extend(child.expression.inline_comments())
+
             if isinstance(child, NewLineOrCommentRule):
-                child_comments = child.actual_comments()
+                child_comments = child.to_list()
                 if child_comments:
                     comments.extend(child_comments)
 
         result = {}
 
         for attribute in attributes:
             result.update(
-                {attribute.identifier.serialize(): attribute.expression.serialize()}
+                {
+                    attribute.identifier.serialize(
+                        options
+                    ): attribute.expression.serialize(options)
+                }
             )
 
-        result.update(
-            {block.labels[0].serialize(): block.serialize() for block in blocks}
-        )
+        result_blocks = defaultdict(list)
+        for block in blocks:
+            name = block.labels[0].serialize(options)
+            if name in result.keys():
+                raise RuntimeError(f"Attribute {name} is already defined.")
+            result_blocks[name].append(block.serialize(options))
+
+        result.update(**result_blocks)
 
-        if comments:
-            result["__comments__"] = comments
+        if options.with_comments:
+            if comments:
+                result["__comments__"] = comments
+            if inline_comments:
+                result["__inline_comments__"] = inline_comments
 
         return result
 
@@ -90,8 +109,8 @@ def rule_name() -> str:
     def body(self) -> BodyRule:
         return self._children[0]
 
-    def serialize(self) -> Any:
-        return self.body.serialize()
+    def serialize(self, options: SerializationOptions = SerializationOptions()) -> Any:
+        return self.body.serialize(options)
 
 
 class BlockRule(LarkRule):
@@ -103,7 +122,7 @@ def rule_name() -> str:
         return "block"
 
     def __init__(self, children, meta: Optional[Meta] = None):
-        super().__init__(children)
+        super().__init__(children, meta)
         *self._labels, self._body = children
 
     @property
@@ -114,9 +133,11 @@ def labels(self) -> List[IdentifierRule]:
     def body(self) -> BodyRule:
         return self._body
 
-    def serialize(self) -> BodyRule:
-        result = self._body.serialize()
+    def serialize(
+        self, options: SerializationOptions = SerializationOptions()
+    ) -> BodyRule:
+        result = self._body.serialize(options)
         labels = self._labels
         for label in reversed(labels[1:]):
-            result = {label.serialize(): result}
+            result = {label.serialize(options): result}
         return result