added correct tests for textblocks

Author: smythi93

src/jast/_jast.py

@@ -39,6 +39,9 @@ def __copy__(self):
         """
         obj = jtype(self).__new__(self.__class__)
         obj.__dict__.update(self.__dict__)
+        for field, value in self:
+            if isinstance(value, list):
+                setattr(obj, field, getattr(self, field)[:])
         return obj
 
 
@@ -213,21 +216,16 @@ def __copy__(self):
         return StringLiteral(self.value)
 
 
-class TextBlock(literal, str):
+class TextBlock(literal):
     """
     Represents a text body literal in the Java AST.
     """
 
     def __init__(self, value: str, *vargs, **kwargs):
         super().__init__(value, *vargs, **kwargs)
 
-    def __new__(cls, value, *vargs, **kwargs):
-        obj = str.__new__(cls, value)
-        TextBlock.__init__(obj, value, *vargs, **kwargs)
-        return obj
-
     def __copy__(self):
-        return TextBlock(self.value)
+        return TextBlock(self.value[:])
 
 
 class NullLiteral(literal):

src/jast/_parser/_convert.py

@@ -782,7 +782,17 @@ def visitLiteral(self, ctx: JavaParser.LiteralContext) -> jast.literal:
         elif ctx.NULL_LITERAL():
             return jast.NullLiteral()
         else:
-            return jast.TextBlock(value=ctx.getText()[3:-3])
+            text = ctx.getText()[3:-3]
+            lines = text.split("\n")[1:]
+            min_spaces = min(
+                len(line) - len(line.lstrip()) for line in lines if line.strip()
+            )
+            return jast.TextBlock(
+                value=[
+                    line[min_spaces:] if line.strip() else line.strip()
+                    for line in lines
+                ]
+            )
 
     def visitIntegerLiteral(
         self, ctx: JavaParser.IntegerLiteralContext

src/jast/_unparse.py

@@ -74,19 +74,24 @@ def seperator(self):
         else:
             self.write(" ")
 
-    def maybe_newline(self):
+    def maybe_newline(self, force_newline: bool = False):
         """
         Add a newline if it isn't the start of the generated source and the indent is not negative.
+        :param force_newline:   If True, a newline is always added.
         """
         if self._source:
-            self.write(self.seperator())
+            if force_newline:
+                self.write("\n")
+            else:
+                self.write(self.seperator())
 
-    def fill(self, text=""):
+    def fill(self, text="", force_newline: bool = False):
         """
         Indent a piece of text and write it to the source.
-        :param text:
+        :param text:           The text to indent.
+        :param force_newline:  If True, a newline is always added.
         """
-        self.maybe_newline()
+        self.maybe_newline(force_newline)
         if self._indent_spaces >= 0:
             self.write(" " * self._indent_spaces * self._indent)
         self.write(text)
@@ -216,7 +221,10 @@ def visit_StringLiteral(self, node: jast.StringLiteral):
         self.write(f'"{node.value}"')
 
     def visit_TextBlock(self, node: jast.TextBlock):
-        self.write(f'"""{node.value}"""')
+        with self.delimit('"""', '"""'):
+            with self.block():
+                for line in node.value:
+                    self.fill(line, force_newline=True)
 
     def visit_NullLiteral(self, node: jast.NullLiteral):
         self.write("null")

tests/test_jast.py

@@ -85,10 +85,9 @@ def test_StringLiteral(self):
         self._test_iteration(string_literal)
 
     def test_TextBlock(self):
-        text_block = jast.TextBlock("foo")
+        text_block = jast.TextBlock(["foo"])
         self.assertIsInstance(text_block, jast.TextBlock)
-        self.assertIsInstance(text_block, str)
-        self.assertEqual("foo", text_block)
+        self.assertEqual(["foo"], text_block.value)
         self._test_iteration(text_block)
 
     def test_NullLiteral(self):

tests/test_parse.py

@@ -1,5 +1,4 @@
 import itertools
-import unittest
 
 from parameterized import parameterized
 
@@ -132,12 +131,25 @@ def test_StringLiteral(self):
         self.assertIsInstance(string_literal.value, jast.StringLiteral)
         self.assertEqual("foo", string_literal.value.value)
 
-    @unittest.skip("TextBlock does not work as expected")
     def test_TextBlock(self):
-        text_block = jast.parse('"""foo"""', jast.ParseMode.EXPR)
+        text_block = jast.parse('"""\nfoo"""', jast.ParseMode.EXPR)
         self.assertIsInstance(text_block, jast.Constant)
         self.assertIsInstance(text_block.value, jast.TextBlock)
-        self.assertEqual("foo", text_block.value.value)
+        self.assertEqual(["foo"], text_block.value.value)
+
+    def test_TextBlock_new_line(self):
+        text_block = jast.parse('"""\nfoo\n"""', jast.ParseMode.EXPR)
+        self.assertIsInstance(text_block, jast.Constant)
+        self.assertIsInstance(text_block.value, jast.TextBlock)
+        self.assertEqual(["foo", ""], text_block.value.value)
+
+    def test_TextBlock_different_indents(self):
+        text_block = jast.parse(
+            '"""\n  foo\n\t  bar\n    \n\t\t\tbaz\n  """', jast.ParseMode.EXPR
+        )
+        self.assertIsInstance(text_block, jast.Constant)
+        self.assertIsInstance(text_block.value, jast.TextBlock)
+        self.assertEqual(["foo", " bar", "", "\tbaz", ""], text_block.value.value)
 
     def test_Null(self):
         null = jast.parse("null", jast.ParseMode.EXPR)

tests/test_unparse.py

@@ -56,8 +56,18 @@ def test_StringLiteral(self):
         self.assertEqual('"foo"', jast.unparse(tree))
 
     def test_TextBlock(self):
-        tree = jast.TextBlock("foo")
-        self.assertEqual('"""foo"""', jast.unparse(tree))
+        tree = jast.TextBlock(["foo"])
+        self.assertEqual('"""\nfoo"""', jast.unparse(tree, indent=-1))
+
+    def test_TextBlock_new_line(self):
+        tree = jast.TextBlock(["foo", ""])
+        self.assertEqual('"""\n    foo\n    """', jast.unparse(tree))
+
+    def test_TextBlock_different_indents(self):
+        tree = jast.TextBlock(["foo", " bar", "", "\tbaz", ""])
+        self.assertEqual(
+            '"""\n    foo\n     bar\n    \n    \tbaz\n    """', jast.unparse(tree)
+        )
 
     def test_NullLiteral(self):
         tree = jast.NullLiteral()