Remove obsolete __repr__() and repr_serialize() on AST elements, change spacing

diff --git a/ast.py b/ast.py
index 5ba683c..e8a8fd9 100644 (file)
--- a/ast.py
+++ b/ast.py
@@ -73,10 +73,6 @@ class AST(element.Element):
         ClassOrFieldDef if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ClassOrFieldDef({0:s})'.format(', '.join(params))
     # GENERATE END
     def generate_class_or_field_def(self, context):
       raise NotImplementedError
@@ -102,10 +98,6 @@ class AST(element.Element):
         Expression if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Expression({0:s})'.format(', '.join(params))
     # GENERATE END
   class Type(element.Element):
     # GENERATE ELEMENT() BEGIN
@@ -129,10 +121,6 @@ class AST(element.Element):
         Type if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Type({0:s})'.format(', '.join(params))
     # GENERATE END
     def generate_serialize(self, context, expr):
       return 'element.serialize_{0:s}({1:s})'.format(
@@ -168,10 +156,6 @@ class AST(element.Element):
         BaseClass if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.BaseClass({0:s})'.format(', '.join(params))
     # GENERATE END
   class ClassBody(element.Element):
     # GENERATE ELEMENT() BEGIN
@@ -195,10 +179,6 @@ class AST(element.Element):
         ClassBody if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ClassBody({0:s})'.format(', '.join(params))
     # GENERATE END
   class ClassName(element.Element):
     # GENERATE ELEMENT() BEGIN
@@ -222,10 +202,6 @@ class AST(element.Element):
         ClassName if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.ClassName({0:s})'.format(', '.join(params))
     # GENERATE END
   class DefaultValue(element.Element):
     # GENERATE ELEMENT() BEGIN
@@ -249,10 +225,6 @@ class AST(element.Element):
         DefaultValue if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.DefaultValue({0:s})'.format(', '.join(params))
     # GENERATE END
   class Identifier(element.Element):
     # GENERATE ELEMENT() BEGIN
@@ -276,10 +248,6 @@ class AST(element.Element):
         Identifier if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Identifier({0:s})'.format(', '.join(params))
     # GENERATE END
     def get_text(self):
       return element.get_text(self, 0)
@@ -303,7 +271,10 @@ class AST(element.Element):
       self.value = value
     def serialize(self, ref_list):
       AST.Expression.serialize(self, ref_list)
-      self.set('value', element.serialize_bool(self.value))
+      self.set(
+        'value',
+        element.serialize_bool(self.value)
+      )
     def deserialize(self, ref_list):
       AST.Expression.deserialize(self, ref_list)
       self.value = element.deserialize_bool(self.get('value', 'false'))
@@ -314,16 +285,6 @@ class AST(element.Element):
       )
       result.value = self.value
       return result
-    def repr_serialize(self, params):
-      AST.Expression.repr_serialize(self, params)
-      if self.value != False:
-        params.append(
-          'value = {0:s}'.format(repr(self.value))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralBool({0:s})'.format(', '.join(params))
     # GENERATE END
   class LiteralInt(Expression):
     # GENERATE ELEMENT(str sign, int base, str digits) BEGIN
@@ -349,9 +310,18 @@ class AST(element.Element):
       self.digits = digits
     def serialize(self, ref_list):
       AST.Expression.serialize(self, ref_list)
-      self.set('sign', element.serialize_str(self.sign))
-      self.set('base', element.serialize_int(self.base))
-      self.set('digits', element.serialize_str(self.digits))
+      self.set(
+        'sign',
+        element.serialize_str(self.sign)
+      )
+      self.set(
+        'base',
+        element.serialize_int(self.base)
+      )
+      self.set(
+        'digits',
+        element.serialize_str(self.digits)
+      )
     def deserialize(self, ref_list):
       AST.Expression.deserialize(self, ref_list)
       self.sign = element.deserialize_str(self.get('sign', ''))
@@ -366,24 +336,6 @@ class AST(element.Element):
       result.base = self.base
       result.digits = self.digits
       return result
-    def repr_serialize(self, params):
-      AST.Expression.repr_serialize(self, params)
-      if self.sign != '':
-        params.append(
-          'sign = {0:s}'.format(repr(self.sign))
-        )
-      if self.base != -1:
-        params.append(
-          'base = {0:s}'.format(repr(self.base))
-        )
-      if self.digits != '':
-        params.append(
-          'digits = {0:s}'.format(repr(self.digits))
-        )
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralInt({0:s})'.format(', '.join(params))
     # GENERATE END
   class LiteralList(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -407,10 +359,6 @@ class AST(element.Element):
         LiteralList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralList({0:s})'.format(', '.join(params))
     # GENERATE END
   class LiteralRef(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -434,10 +382,6 @@ class AST(element.Element):
         LiteralRef if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralRef({0:s})'.format(', '.join(params))
     # GENERATE END
   class LiteralSet(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -461,10 +405,6 @@ class AST(element.Element):
         LiteralSet if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralSet({0:s})'.format(', '.join(params))
     # GENERATE END
   class LiteralStr(Expression):
     # GENERATE ELEMENT() BEGIN
@@ -488,10 +428,6 @@ class AST(element.Element):
         LiteralStr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.LiteralStr({0:s})'.format(', '.join(params))
     # GENERATE END
   class Text(element.Element):
     class Escape(element.Element):
@@ -514,7 +450,10 @@ class AST(element.Element):
         self.value = value
       def serialize(self, ref_list):
         element.Element.serialize(self, ref_list)
-        self.set('value', element.serialize_int(self.value))
+        self.set(
+          'value',
+          element.serialize_int(self.value)
+        )
       def deserialize(self, ref_list):
         element.Element.deserialize(self, ref_list)
         self.value = element.deserialize_int(self.get('value', '-1'))
@@ -525,16 +464,6 @@ class AST(element.Element):
         )
         result.value = self.value
         return result
-      def repr_serialize(self, params):
-        element.Element.repr_serialize(self, params)
-        if self.value != -1:
-          params.append(
-            'value = {0:s}'.format(repr(self.value))
-          )
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Text.Escape({0:s})'.format(', '.join(params))
       # GENERATE END
     # GENERATE ELEMENT() BEGIN
     def __init__(
@@ -557,10 +486,6 @@ class AST(element.Element):
         Text if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Text({0:s})'.format(', '.join(params))
     # GENERATE END
   class TypeBool(Type):
     # GENERATE ELEMENT() BEGIN
@@ -584,10 +509,6 @@ class AST(element.Element):
         TypeBool if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeBool({0:s})'.format(', '.join(params))
     # GENERATE END
   class TypeInt(Type):
     # GENERATE ELEMENT() BEGIN
@@ -611,10 +532,6 @@ class AST(element.Element):
         TypeInt if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeInt({0:s})'.format(', '.join(params))
     # GENERATE END
   class TypeList(Type):
     # GENERATE ELEMENT() BEGIN
@@ -638,10 +555,6 @@ class AST(element.Element):
         TypeList if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeList({0:s})'.format(', '.join(params))
     # GENERATE END
     def generate_serialize(self, context, expr):
       indent_save = context.indent
@@ -699,10 +612,6 @@ class AST(element.Element):
         TypeRef if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeRef({0:s})'.format(', '.join(params))
     # GENERATE END
     def generate_serialize(self, context, expr):
       return 'element.serialize_ref({0:s}, ref_list)'.format(expr)
@@ -730,10 +639,6 @@ class AST(element.Element):
         TypeSet if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeSet({0:s})'.format(', '.join(params))
     # GENERATE END
     def generate_serialize(self, context, expr):
       indent_save = context.indent
@@ -795,10 +700,6 @@ class AST(element.Element):
         TypeStr if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.TypeStr({0:s})'.format(', '.join(params))
     # GENERATE END
   class Section1(element.Element):
     class CodeBlock(element.Element):
@@ -823,10 +724,6 @@ class AST(element.Element):
           CodeBlock if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section1.CodeBlock({0:s})'.format(', '.join(params))
       # GENERATE END
     # GENERATE ELEMENT() BEGIN
     def __init__(
@@ -849,10 +746,6 @@ class AST(element.Element):
         Section1 if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section1({0:s})'.format(', '.join(params))
     # GENERATE END
   class Section2(element.Element):
     class ClassDef(element.Element):
@@ -877,10 +770,6 @@ class AST(element.Element):
           ClassDef if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section2.ClassDef({0:s})'.format(', '.join(params))
       # GENERATE END
       def generate_class_or_field_def(self, context):
         class_name = self[0].get_text()
@@ -1096,10 +985,6 @@ class AST(element.Element):
           FieldDef if factory is None else factory
         )
         return result
-      def __repr__(self):
-        params = []
-        self.repr_serialize(params)
-        return 'ast.AST.Section2.FieldDef({0:s})'.format(', '.join(params))
       # GENERATE END
       def generate_class_or_field_def(self, context):
         context.fields.append(self)
@@ -1124,10 +1009,6 @@ class AST(element.Element):
         Section2 if factory is None else factory
       )
       return result
-    def __repr__(self):
-      params = []
-      self.repr_serialize(params)
-      return 'ast.AST.Section2({0:s})'.format(', '.join(params))
     # GENERATE END
   # GENERATE ELEMENT() BEGIN
   def __init__(
@@ -1150,10 +1031,6 @@ class AST(element.Element):
       AST if factory is None else factory
     )
     return result
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'ast.AST({0:s})'.format(', '.join(params))
   # GENERATE END
 
 # GENERATE FACTORY(element.Element) BEGIN

diff --git a/element.py b/element.py
index 2d02217..367a9b7 100644 (file)
--- a/element.py
+++ b/element.py
@@ -1,4 +1,4 @@
-# Copyright (C) 2018 Nick Downing <nick@ndcode.org>
+# Copyright (C) 2019 Nick Downing <nick@ndcode.org>
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # This program is free software; you can redistribute it and/or modify it under
@@ -40,17 +40,6 @@ class Element(xml.etree.ElementTree._Element_Py):
     result.tail = self.tail
     result[:] = [i.copy() for i in self]
     return result
-  def repr_serialize(self, params):
-    if len(self):
-      params.append(
-        'children = [{0:s}]'.format(
-          ', '.join([repr(i) for i in self])
-        )
-      )
-  def __repr__(self):
-    params = []
-    self.repr_serialize(params)
-    return 'element.Element({0:s})'.format(', '.join(params))
 
 bool_to_str = ['false', 'true']
 def serialize_bool(value):

diff --git a/generate_ast.py b/generate_ast.py
index 0e3155f..f65d4f3 100755 (executable)
--- a/generate_ast.py
+++ b/generate_ast.py
@@ -163,7 +163,11 @@ while len(line):
         sys.stdout.write(
           '''{0:s}def serialize(self, ref_list):
 {1:s}  {2:s}.serialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -171,16 +175,26 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in self.{6:s}])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in self.{9:s}
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
@@ -189,34 +203,54 @@ while len(line):
             sys.stdout.write(
               '''{0:s}  self.set(
 {1:s}    '{2:s}',
-{3:s}    ' '.join([element.serialize_{4:s}(i{5:s}) for i in sorted(self.{6:s})])
-{7:s}  )
+{3:s}    ' '.join(
+{4:s}      [
+{5:s}        element.serialize_{6:s}(i{7:s})
+{8:s}        for i in sorted(self.{9:s})
+{10:s}      ]
+{11:s}    )
+{12:s}  )
 '''.format(
                 indent,
                 indent,
                 name,
                 indent,
+                indent,
+                indent,
                 subtype,
                 ', ref_list' if subtype == 'ref' else '',
+                indent,
                 name,
+                indent,
+                indent,
                 indent
               )
             )
           else:
             sys.stdout.write(
-              '''{0:s}  self.set('{1:s}', element.serialize_{2:s}(self.{3:s}{4:s}))
+              '''{0:s}  self.set(
+{1:s}    '{2:s}',
+{3:s}    element.serialize_{4:s}(self.{5:s}{6:s})
+{7:s}  )
 '''.format(
+                indent,
                 indent,
                 name,
+                indent,
                 type,
                 name,
-                ', ref_list' if type == 'ref' else ''
+                ', ref_list' if type == 'ref' else '',
+                indent
               )
             )
         sys.stdout.write(
           '''{0:s}def deserialize(self, ref_list):
 {1:s}  {2:s}.deserialize(self, ref_list)
-'''.format(indent, indent, full_base_class)
+'''.format(
+            indent,
+            indent,
+            full_base_class
+          )
         )
         for type, name in fields:
           if type[:5] == 'list(' and type[-1:] == ')':
@@ -299,89 +333,9 @@ while len(line):
           indent
         )
       )
-      if len(fields):
-        sys.stdout.write(
-          '''{0:s}def repr_serialize(self, params):
-{1:s}  {2:s}.repr_serialize(self, params)
-'''.format(
-            indent,
-            indent,
-            full_base_class
-          )
-        )
-        for type, name in fields:
-          if type[:5] == 'list(' and type[-1:] == ')':
-            subtype = type[5:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = [{{0:s}}]'.format(
-{5:s}        ', '.join([repr(i) for i in self.{6:s}])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          elif type[:4] == 'set(' and type[-1:] == ')':
-            subtype = type[4:-1]
-            sys.stdout.write(
-              '''{0:s}  if len(self.{1:s}):
-{2:s}    params.append(
-{3:s}      '{4:s} = set([{{0:s}}])'.format(
-{5:s}        ', '.join([repr(i) for i in sorted(self.{6:s})])
-{7:s}      )
-{8:s}    )
-'''.format(
-                indent,
-                name,
-                indent,
-                indent,
-                name,
-                indent,
-                name,
-                indent,
-                indent
-              )
-            )
-          else:
-            sys.stdout.write(
-              '''{0:s}  if self.{1:s} != {2:s}:
-{3:s}    params.append(
-{4:s}      '{5:s} = {{0:s}}'.format(repr(self.{6:s}))
-{7:s}    )
-'''.format(
-                indent,
-                name,
-                default_value[type],
-                indent,
-                indent,
-                name,
-                name,
-                indent
-              )
-            )
       sys.stdout.write(
-        '''{0:s}def __repr__(self):
-{1:s}  params = []
-{2:s}  self.repr_serialize(params)
-{3:s}  return '{4:s}{5:s}({{0:s}})'.format(', '.join(params))
-{6:s}# GENERATE END
+        '''{0:s}# GENERATE END
 '''.format(
-          indent,
-          indent,
-          indent,
-          indent,
-          package_name,
-          '.'.join([i for _, i, _, _ in stack]),
           indent
         )
       )