minor improvements to deserializer.py and formatter.py

Author: kkozik-amplify

hcl2/deserializer.py

@@ -1,8 +1,8 @@
 import json
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from functools import lru_cache
-from typing import Any, TextIO, List, Union, Optional
+from functools import cached_property
+from typing import Any, TextIO, List, Union
 
 from regex import regex
 
@@ -55,7 +55,6 @@
     HEREDOC_TEMPLATE,
     COLON,
 )
-from hcl2.rules.whitespace import NewLineOrCommentRule
 from hcl2.transformer import RuleTransformer
 from hcl2.utils import HEREDOC_TRIM_PATTERN, HEREDOC_PATTERN
 
@@ -83,11 +82,8 @@ def load(self, file: TextIO) -> LarkElement:
 class BaseDeserializer(LarkElementTreeDeserializer):
     def __init__(self, options=None):
         super().__init__(options)
-        self._current_line = 1
-        self._last_new_line: Optional[NewLineOrCommentRule] = None
 
-    @property
-    @lru_cache
+    @cached_property
     def _transformer(self) -> RuleTransformer:
         return RuleTransformer()
 
@@ -119,27 +115,29 @@ def _deserialize(self, value: Any) -> LarkElement:
 
     def _deserialize_block_elements(self, value: dict) -> List[LarkRule]:
         children = []
-        for key, value in value.items():
-            if self._is_block(value):
+        for key, val in value.items():
+            if self._is_block(val):
                 # this value is a list of blocks, iterate over each block and deserialize them
-                for block in value:
+                for block in val:
                     children.append(self._deserialize_block(key, block))
 
             else:
                 # otherwise it's just an attribute
                 if key != IS_BLOCK:
-                    children.append(self._deserialize_attribute(key, value))
+                    children.append(self._deserialize_attribute(key, val))
 
         return children
 
     def _deserialize_text(self, value: Any) -> LarkRule:
-        try:
-            int_val = int(value)
-            if "." in str(value):
-                return FloatLitRule([FloatLiteral(float(value))])
-            return IntLitRule([IntLiteral(int_val)])
-        except ValueError:
-            pass
+        # bool must be checked before int since bool is a subclass of int
+        if isinstance(value, bool):
+            return self._deserialize_identifier(str(value).lower())
+
+        if isinstance(value, float):
+            return FloatLitRule([FloatLiteral(value)])
+
+        if isinstance(value, int):
+            return IntLitRule([IntLiteral(value)])
 
         if isinstance(value, str):
             if value.startswith('"') and value.endswith('"'):
@@ -160,9 +158,6 @@ def _deserialize_text(self, value: Any) -> LarkRule:
 
             return self._deserialize_identifier(value)
 
-        elif isinstance(value, bool):
-            return self._deserialize_identifier(str(value).lower())
-
         return self._deserialize_identifier(str(value))
 
     def _deserialize_identifier(self, value: str) -> IdentifierRule:
@@ -283,8 +278,8 @@ def _deserialize_list(self, value: List) -> TupleRule:
 
     def _deserialize_object(self, value: dict) -> ObjectRule:
         children = []
-        for key, value in value.items():
-            children.append(self._deserialize_object_elem(key, value))
+        for key, val in value.items():
+            children.append(self._deserialize_object_elem(key, val))
 
             if self.options.object_elements_trailing_comma:
                 children.append(COMMA())
@@ -342,6 +337,6 @@ def _contains_block_marker(self, obj: dict) -> bool:
                 return True
             if isinstance(value, list):
                 for element in value:
-                    if self._contains_block_marker(element):
+                    if isinstance(element, dict) and self._contains_block_marker(element):
                         return True
         return False

hcl2/formatter.py

@@ -42,18 +42,14 @@ def format_tree(self, tree: LarkElement):
 class BaseFormatter(LarkElementTreeFormatter):
     def __init__(self, options: FormatterOptions = None):
         super().__init__(options)
-        self._current_line = 1
-        self._current_indent_level = 0
+        self._last_new_line: NewLineOrCommentRule = None
 
     def format_tree(self, tree: LarkElement):
         if isinstance(tree, StartRule):
             self.format_start_rule(tree)
 
     def format_start_rule(self, rule: StartRule):
         self.format_body_rule(rule.body, 0)
-        # for child in rule.body.children:
-        #     if isinstance(child, BlockRule):
-        #         self.format_block_rule(child, 1)
 
     def format_block_rule(self, rule: BlockRule, indent_level: int = 0):
         if self.options.vertically_align_attributes:
@@ -87,7 +83,8 @@ def format_body_rule(self, rule: BodyRule, indent_level: int = 0):
                     new_children.insert(-2, self._build_newline(indent_level))
                 new_children.append(self._build_newline(indent_level, 2))
 
-        new_children.pop(-1)
+        if new_children:
+            new_children.pop(-1)
         rule._children = new_children
 
     def format_attribute_rule(self, rule: AttributeRule, indent_level: int = 0):
@@ -158,7 +155,7 @@ def format_expression(self, rule: ExprTermRule, indent_level: int = 0):
             self.format_forobjectexpr(rule.expression, indent_level)
 
         elif isinstance(rule.expression, ExprTermRule):
-            self.format_expression(rule.expression)
+            self.format_expression(rule.expression, indent_level)
 
     def format_fortupleexpr(self, expression: ForTupleExprRule, indent_level: int = 0):
         for child in expression.children:
@@ -169,7 +166,6 @@ def format_fortupleexpr(self, expression: ForTupleExprRule, indent_level: int =
         for index in indexes:
             expression.children[index] = self._build_newline(indent_level)
         self._deindent_last_line()
-        # expression.children[8] = self._build_newline(indent_level - 1)
 
     def format_forobjectexpr(
         self, expression: ForObjectExprRule, indent_level: int = 0
@@ -192,23 +188,28 @@ def _vertically_align_attributes_in_body(self, body: BodyRule):
                 attributes_sequence.append(child)
 
             elif attributes_sequence:
-                max_length = max(
-                    len(attribute.identifier.token.value)
-                    for attribute in attributes_sequence
-                )
-                for attribute in attributes_sequence:
-                    name_length = len(attribute.identifier.token.value)
-                    spaces_to_add = max_length - name_length
-                    attribute.children[1].set_value(
-                        " " * spaces_to_add + attribute.children[1].value
-                    )
+                self._align_attribute_group(attributes_sequence)
                 attributes_sequence = []
 
+        if attributes_sequence:
+            self._align_attributes_sequence(attributes_sequence)
+
+    def _align_attributes_sequence(self, attributes_sequence: List[AttributeRule]):
+        max_length = max(
+            len(attribute.identifier.token.value)
+            for attribute in attributes_sequence
+        )
+        for attribute in attributes_sequence:
+            name_length = len(attribute.identifier.token.value)
+            spaces_to_add = max_length - name_length
+            attribute.children[1].set_value(
+                " " * spaces_to_add + attribute.children[1].value
+            )
+
     def _vertically_align_object_elems(self, rule: ObjectRule):
         max_length = max(len(elem.key.serialize()) for elem in rule.elements)
         for elem in rule.elements:
             key_length = len(elem.key.serialize())
-            print(elem.key.serialize(), key_length)
 
             spaces_to_add = max_length - key_length
 
@@ -218,17 +219,6 @@ def _vertically_align_object_elems(self, rule: ObjectRule):
 
             elem.children[1].set_value(" " * spaces_to_add + separator.value)
 
-    def _move_to_next_line(self, times: int = 1):
-        self._current_line += times
-
-    def _increase_indent_level(self, times: int = 1):
-        self._current_indent_level += times
-
-    def _decrease_indent_level(self, times: int = 1):
-        self._current_indent_level -= times
-        if self._current_indent_level < 0:
-            self._current_indent_level = 0
-
     def _build_newline(
         self, next_line_indent: int = 0, count: int = 1
     ) -> NewLineOrCommentRule:
@@ -247,16 +237,3 @@ def _deindent_last_line(self, times: int = 1):
         for i in range(times):
             if token.value.endswith(" " * self.options.indent_length):
                 token.set_value(token.value[: -self.options.indent_length])
-
-    # def _build_meta(self, indent_level: int = 0, length: int = 0) -> Meta:
-    #     result = Meta()
-    #     result.empty = length == 0
-    #     result.line = self._current_line
-    #     result.column = indent_level * self.options.indent_length
-    #     # result.start_pos =
-    #     # result.end_line =
-    #     # result.end_column =
-    #     # result.end_pos =
-    #     # result.orig_expansion =
-    #     # result.match_tree =
-    #     return result