Merge pull request #4 from courage-tci/dev

Compact rendering and less parens

.github/workflows/test.yml

@@ -5,7 +5,6 @@ on:
   push:
     branches:
       - lord
-      - dev
   pull_request:
 
 jobs:

gekkota.py

@@ -48,8 +48,11 @@ class Renderable:
     def render(self, tab_size: int) -> StrGen:
         return NotImplemented
 
-    def render_str(self, tab_size: int = 4) -> str:
-        return "".join([*self.render(tab_size)])
+    def render_str(self, tab_size: int = 4, compact: bool = False) -> str:
+        generator = self.render(tab_size)
+        if compact:
+            generator = Utils.make_compact(generator)
+        return "".join([*generator])
 
 
 class Utils:
@@ -69,13 +72,35 @@ def separated(separator: str, renderables: Sequence[Renderable], tab_size: int)
             return
         yield from renderables[0].render(tab_size)
         for renderable in renderables[1:]:
-            yield separator
+            yield from separator
             yield from renderable.render(tab_size)
 
     @staticmethod
     def comma_separated(renderables: Sequence[Renderable], tab_size: int) -> StrGen:
         yield from Utils.separated(", ", renderables, tab_size)
 
+    @staticmethod
+    def make_compact(generator: StrGen) -> StrGen:
+        is_tab = False
+        last_token_isalpha = False
+        for token in generator:
+            if token == "\n":
+                is_tab = True
+            elif token != " ":
+                is_tab = False
+
+            if token == " " and not is_tab:
+                continue
+
+            if token.startswith("0."):
+                token = token[1:]
+
+            if token[0].isalnum() and last_token_isalpha:
+                yield " "
+
+            last_token_isalpha = token[-1].isalpha()
+            yield token
+
 
 class Statement(Renderable):
     """statement, biggest separate part of code"""
@@ -273,7 +298,8 @@ def render(self, tab_size: int) -> StrGen:
         yield self.parens[0]
         yield from Utils.comma_separated(self.values, tab_size)
         if len(self.values) == 1 and isinstance(self, TupleExpr):
-            yield ", "
+            yield ","
+            yield " "
         yield self.parens[1]
 
 
@@ -301,7 +327,8 @@ def __init__(self, condition: Expression):
         self.condition = condition
 
     def render(self, tab_size: int) -> StrGen:
-        yield "if "
+        yield "if"
+        yield " "
         yield from self.condition.render(tab_size)
 
 
@@ -311,9 +338,12 @@ def __init__(self, target: Expression, iterator: Expression):
         self.iterator = iterator
 
     def render(self, tab_size: int) -> StrGen:
-        yield "for "
+        yield "for"
+        yield " "
         yield from self.target.render(tab_size)
-        yield " in "
+        yield " "
+        yield "in"
+        yield " "
         yield from self.iterator.render(tab_size)
 
 
@@ -333,7 +363,8 @@ def __init__(self, key: Expression, value: Expression):
 
     def render(self, tab_size: int) -> StrGen:
         yield from self.key.render(tab_size)
-        yield ": "
+        yield ":"
+        yield " "
         yield from self.value.render(tab_size)
 
 
@@ -427,7 +458,8 @@ def __init__(self, awaitable: Expression):
         self.awaitable = awaitable
 
     def render(self, tab_size: int) -> StrGen:
-        yield "await "
+        yield "await"
+        yield " "
         yield from self.awaitable.render(tab_size)
 
 
@@ -439,14 +471,17 @@ def __init__(self, name: str, annotation: Optional[Expression] = None):
     def render(self, tab_size: int) -> StrGen:
         yield self.name
         if self.annotation:
-            yield ": "
+            yield ":"
+            yield " "
             yield from self.annotation.render(tab_size)
 
 
 class Literal(Expression):
     priority = 15
     def __init__(self, value: Union[int, float, complex, str, bytes, bool, None]):
         self.value = value
+        if isinstance(value, (str, bytes)):
+            self.priority = 100
 
     def render(self, tab_size: int) -> StrGen:
         yield repr(self.value)
@@ -493,11 +528,14 @@ def __init__(
     def render(self, tab_size: int) -> StrGen:
         yield self.name
         if self.annotation:
-            yield ": "
+            yield ":"
+            yield " "
             yield from self.annotation.render(tab_size)
         if self.default_value:
             if self.annotation:
-                yield " = "
+                yield " "
+                yield "="
+                yield " "
             else:
                 yield "="
             yield from self.default_value.render(tab_size)
@@ -558,7 +596,8 @@ def render_head(self, tab_size: int) -> StrGen:
 
     def render(self, tab_size: int) -> StrGen:
         yield from self.render_head(tab_size)
-        yield ": "
+        yield ":"
+        yield " "
         yield from self.body.render(tab_size)
 
 
@@ -572,7 +611,8 @@ def render(self, tab_size: int) -> StrGen:
         if self.args:
             yield " "
             yield from Utils.comma_separated(self.args, tab_size)
-        yield ": "
+        yield ":"
+        yield " "
         yield from self.body.render(tab_size)
 
 
@@ -598,13 +638,16 @@ def __init__(self, name: str, args: Sequence[AnyFuncArg], body: Statement, *, rt
         self.rtype = rtype
 
     def render_head(self, tab_size: int) -> StrGen:
-        yield "def "
+        yield "def"
+        yield " "
         yield self.name
         yield "("
         yield from Utils.comma_separated(self.args, tab_size)
         yield ")"
         if self.rtype:
-            yield " -> "
+            yield " "
+            yield "->"
+            yield " "
             yield from self.rtype.render(tab_size)
 
 
@@ -616,7 +659,8 @@ def __init__(self, name: str, args: Sequence[AnyCallArg], body: Statement):
         self.args = args
 
     def render_head(self, tab_size: int) -> StrGen:
-        yield "class "
+        yield "class"
+        yield " "
         yield self.name
         if self.args:
             yield "("
@@ -630,13 +674,15 @@ def __init__(self, condition: Expression, body: Statement):
         self.body = body
 
     def render_head(self, tab_size: int) -> StrGen:
-        yield "if "
+        yield "if"
+        yield " "
         yield from self.condition.render(tab_size)
 
 
 class ElifStmt(IfStmt):
     def render_head(self, tab_size: int) -> StrGen:
-        yield "elif "
+        yield "elif"
+        yield " "
         yield from self.condition.render(tab_size)
 
 
@@ -650,7 +696,8 @@ def render_head(self, tab_size: int) -> StrGen:
 
 class WhileStmt(IfStmt):
     def render_head(self, tab_size: int):
-        yield "while "
+        yield "while"
+        yield " "
         yield from self.condition.render(tab_size)
 
 
@@ -661,9 +708,12 @@ def __init__(self, target: Expression, iterator: Expression, body: Statement):
         self.body = body
 
     def render_head(self, tab_size: int) -> StrGen:
-        yield "for "
+        yield "for"
+        yield " "
         yield from self.target.render(tab_size)
-        yield " in "
+        yield " "
+        yield "in"
+        yield " "
         yield from self.iterator.render(tab_size)
 
 
@@ -690,7 +740,9 @@ def render_head(self, tab_size: int) -> StrGen:
             else:
                 yield from self.exceptions[0].render(tab_size)
             if self.alias:
-                yield " as "
+                yield " "
+                yield "as"
+                yield " "
                 yield from self.alias.render(tab_size)
 
 
@@ -713,7 +765,9 @@ def render(self, tab_size: int) -> StrGen:
             yield " "
             yield from self.exception.render(tab_size)
             if self.scope:
-                yield " from "
+                yield " "
+                yield "from"
+                yield " "
                 yield from self.scope.render(tab_size)
 
 
@@ -725,7 +779,9 @@ def __init__(self, expression: Expression, alias: Optional[str] = None):
     def render(self, tab_size: int) -> StrGen:
         yield from self.expression.render(tab_size)
         if self.alias:
-            yield " as "
+            yield " "
+            yield "as"
+            yield " "
             yield self.alias
 
 
@@ -735,7 +791,8 @@ def __init__(self, targets: Sequence[Union[WithTarget, Expression]], body: State
         self.body = body
 
     def render_head(self, tab_size: int) -> StrGen:
-        yield "with "
+        yield "with"
+        yield " "
         yield from Utils.comma_separated(self.targets, tab_size)
 
 
@@ -786,13 +843,15 @@ def __init__(self, names: Sequence[Name]):
         self.names = names
 
     def render(self, tab_size: int) -> StrGen:
-        yield "global "
+        yield "global"
+        yield " "
         yield from Utils.comma_separated(self.names, tab_size)
 
 
 class NonLocalStmt(GlobalStmt):
     def render(self, tab_size: int) -> StrGen:
-        yield "nonlocal "
+        yield "nonlocal"
+        yield " "
         yield from Utils.comma_separated(self.names, tab_size)
 
 
@@ -801,7 +860,8 @@ def __init__(self, target: Expression):
         self.target = target
 
     def render(self, tab_size: int) -> StrGen:
-        yield "del "
+        yield "del"
+        yield " "
         yield from self.target.render(tab_size)
 
 
@@ -810,7 +870,8 @@ def __init__(self, expression: Expression):
         self.expression = expression
 
     def render(self, tab_size: int) -> StrGen:
-        yield "assert "
+        yield "assert"
+        yield " "
         yield from self.expression.render(tab_size)
 
 
@@ -819,7 +880,8 @@ def __init__(self, statement: Union[Statement, GeneratorFor]):
         self.statement = statement
 
     def render(self, tab_size: int) -> StrGen:
-        yield "async "
+        yield "async"
+        yield " "
         yield from self.statement.render(tab_size)
 
 
@@ -881,7 +943,9 @@ def __init__(self, name: Name, alias: Optional[Name] = None):
     def render(self, tab_size: int) -> StrGen:
         yield from self.name.render(tab_size)
         if self.alias:
-            yield " as "
+            yield " "
+            yield "as"
+            yield " "
             yield from self.alias.render(tab_size)
 
 
@@ -894,7 +958,8 @@ def __init__(self, names: Sequence[AnyImportAlias]):
         self.names = names
 
     def render(self, tab_size: int) -> StrGen:
-        yield "import "
+        yield "import"
+        yield " "
         yield from Utils.comma_separated(self.names, tab_size)
 
 
@@ -904,9 +969,12 @@ def __init__(self, source: AnyImportSource, names: Sequence[AnyImportAlias]):
         self.names = names
 
     def render(self, tab_size: int) -> StrGen:
-        yield "from "
+        yield "from"
+        yield " "
         yield from self.source.render(tab_size)
-        yield " import "
+        yield " "
+        yield "import"
+        yield " "
         yield from Utils.comma_separated(self.names, tab_size)
 
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "gekkota"
-version = "0.2.6"
+version = "0.3.6"
 description = "Python code-generation for Python"
 authors = ["Dmitry Gritsenko <k01419q45@ya.ru>"]
 license = "MIT"

test/test_blocks.py

@@ -10,6 +10,7 @@
 class TestClass:
     def test_block(self):
         assert Block([]).render_str(tab_size=4) == "\n    pass"
+        assert Block([]).render_str(tab_size=4, compact=True) == "\n    pass"
         assert Block([a]).render_str(tab_size=4) == "\n    a"
         assert Block([a, b]).render_str(tab_size=4) == "\n    a\n    b"