reorganize code

Author: kkozik-amplify

hcl2/rule_transformer.py

@@ -0,0 +1,12 @@
+from json import JSONEncoder
+from typing import Any
+
+from hcl2.rule_transformer.rules.abstract import LarkRule
+
+
+class LarkEncoder(JSONEncoder):
+    def default(self, obj: Any):
+        if isinstance(obj, LarkRule):
+            return obj.serialize()
+        else:
+            return super().default(obj)

hcl2/rule_transformer/__init__.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from typing import Any, Union, List, Optional
+
+from lark import Token, Tree
+from lark.tree import Meta
+
+
+class LarkElement(ABC):
+    @abstractmethod
+    def tree(self) -> Token:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def serialize(self) -> Any:
+        raise NotImplementedError()
+
+
+class LarkToken(LarkElement):
+    def __init__(self, name: str, value: Union[str, int]):
+        self._name = name
+        self._value = value
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def value(self):
+        return self._value
+
+    def serialize(self) -> Any:
+        return self._value
+
+    def tree(self) -> Token:
+        return Token(self.name, self.value)
+
+    def __str__(self) -> str:
+        return str(self._value)
+
+    def __repr__(self) -> str:
+        return f"<LarkToken instance: {self._name} {self._value}>"
+
+
+EQ_Token = LarkToken
+COLON_TOKEN = LarkToken
+LPAR_TOKEN = LarkToken  # left parenthesis
+RPAR_TOKEN = LarkToken  # right parenthesis
+
+
+class TokenSequence:
+    def __init__(self, tokens: List[LarkToken]):
+        self.tokens = tokens
+
+    def tree(self) -> List[Token]:
+        return [token.tree() for token in self.tokens]
+
+    def joined(self):
+        return "".join(str(token) for token in self.tokens)
+
+
+class LarkRule(ABC):
+    @staticmethod
+    @abstractmethod
+    def rule_name() -> str:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def serialize(self) -> Any:
+        raise NotImplementedError()
+
+    @property
+    def children(self) -> List[LarkElement]:
+        return self._children
+
+    def tree(self) -> Tree:
+        result_children = []
+        for child in self._children:
+            if child is None:
+                continue
+
+            if isinstance(child, TokenSequence):
+                result_children.extend(child.tree())
+            else:
+                result_children.append(child.tree())
+
+        return Tree(self.rule_name(), result_children)
+
+    def __init__(self, children, meta: Optional[Meta] = None):
+        self._children = children
+        self._meta = meta
+
+    def __repr__(self):
+        return f"<LarkRule: {self.__class__.__name__} ({';'.join(str(child) for child in self._children)})>"

hcl2/rule_transformer/json.py

@@ -0,0 +1,122 @@
+from typing import Tuple, Any, List, Union, Optional
+
+from lark.tree import Meta
+
+from hcl2.rule_transformer.rules.abstract import LarkRule, EQ_Token
+from hcl2.rule_transformer.rules.expression import Expression
+from hcl2.rule_transformer.rules.token_sequence import IdentifierRule
+
+from hcl2.rule_transformer.rules.whitespace import NewLineOrCommentRule
+
+
+class AttributeRule(LarkRule):
+    _children: Tuple[
+        IdentifierRule,
+        EQ_Token,
+        Expression,
+    ]
+
+    @staticmethod
+    def rule_name() -> str:
+        return "attribute"
+
+    @property
+    def identifier(self) -> IdentifierRule:
+        return self._children[0]
+
+    @property
+    def expression(self) -> Expression:
+        return self._children[2]
+
+    def serialize(self) -> Any:
+        return {self.identifier.serialize(): self.expression.serialize()}
+
+
+class BodyRule(LarkRule):
+
+    _children: List[
+        Union[
+            NewLineOrCommentRule,
+            AttributeRule,
+            "BlockRule",
+        ]
+    ]
+
+    @staticmethod
+    def rule_name() -> str:
+        return "body"
+
+    def serialize(self) -> Any:
+        blocks: List[BlockRule] = []
+        attributes: List[AttributeRule] = []
+        comments = []
+
+        for child in self._children:
+            if isinstance(child, BlockRule):
+                blocks.append(child)
+            if isinstance(child, AttributeRule):
+                attributes.append(child)
+            if isinstance(child, NewLineOrCommentRule):
+                child_comments = child.actual_comments()
+                if child_comments:
+                    comments.extend(child_comments)
+
+        result = {}
+
+        for attribute in attributes:
+            result.update(
+                {attribute.identifier.serialize(): attribute.expression.serialize()}
+            )
+
+        result.update(
+            {block.labels[0].serialize(): block.serialize() for block in blocks}
+        )
+
+        if comments:
+            result["__comments__"] = comments
+
+        return result
+
+
+class StartRule(LarkRule):
+
+    _children: Tuple[BodyRule]
+
+    @staticmethod
+    def rule_name() -> str:
+        return "start"
+
+    @property
+    def body(self) -> BodyRule:
+        return self._children[0]
+
+    def serialize(self) -> Any:
+        return self.body.serialize()
+
+
+class BlockRule(LarkRule):
+
+    _children: Tuple[BodyRule]
+
+    @staticmethod
+    def rule_name() -> str:
+        return "block"
+
+    def __init__(self, children, meta: Optional[Meta] = None):
+        super().__init__(children)
+        *self._labels, self._body = children
+
+    @property
+    def labels(self) -> List[IdentifierRule]:
+        return list(filter(lambda label: label is not None, self._labels))
+
+    @property
+    def body(self) -> BodyRule:
+        return self._body
+
+    def serialize(self) -> BodyRule:
+        result = self._body.serialize()
+        labels = self._labels
+        for label in reversed(labels[1:]):
+            result = {label.serialize(): result}
+        return result