[Extension API Extern Generation] Support inline object definitions

tools/json_schema_compiler/code.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 class Code(object):
   """A convenience object for constructing code.
 
   Logically each object should be a block of code. All methods except |Render|
   and |IsEmpty| return self.
   """
   def __init__(self, indent_size=2, comment_length=80):
     self._code = []
-    self._indent_level = 0
     self._indent_size = indent_size
     self._comment_length = comment_length
+    self._line_prefixes = []
 
-  def Append(self, line='', substitute=True, indent_level=None):
+  def Append(self, line='',
+             substitute=True,
+             indent_level=None,
+             new_line=True,
+             strip_right=True):
     """Appends a line of code at the current indent level or just a newline if
-    line is not specified. Trailing whitespace is stripped.
+    line is not specified.
 
     substitute: indicated whether this line should be affected by
     code.Substitute().
+    new_line: whether this should be added as a new line, or should be appended
+        to the last line of the code.

[Tyler Breisacher (Chromium), 2015/03/27 22:52:18]

I'm wary of the number of parameters we're adding here.

  c.Append('foo', new_line=True)

is just shorthand for

  c.Append().Append('foo');

right? I'm inclined to think the latter form is better since it keeps the API
simpler (and is actually shorter)

[Devlin, 2015/03/27 23:04:09]

Well, no - new_line=True is the default.  And if it wasn't, c.Append() would be
a no-op (it would append an empty string onto the last line).

Also, I think it is more common to want
c.Append(line1)
c.Append(line2)
c.Append(line3)
than
c.Append(line1-pt1)
c.Append(line1-pt2)
c.Append(line1-pt3)
but the latter is very useful for the JS docs, when we have recursive generation
of, e.g., object types (and generating them as strings doesn't really make as
much sense).

Of course, we could just separate these into two methods, Append() and
Continue() or some such thing.

[Tyler Breisacher (Chromium), 2015/03/27 23:22:32]

Oh right. Okay well, I guess this is good then. I just get worried when I see
lots of parameters being added to a method.

[Devlin, 2015/03/27 23:39:46]

I appreciate the skepticism. :)  I tried to figure out the simplest way, and,
sadly, adding the extra parameters was actually preferable to the alternatives.

+    strip_right: whether or not trailing whitespace should be stripped.
     """
-    if indent_level is None:
-      indent_level = self._indent_level
-    self._code.append(Line(((' ' * indent_level) + line).rstrip(),
-                      substitute=substitute))
+
+    prefix = indent_level * ' ' if indent_level else ''.join(
+        self._line_prefixes)
+
+    if strip_right:
+      line = line.rstrip()
+
+    if not new_line and self._code:
+      self._code[-1].value += line
+    else:
+      self._code.append(Line(prefix + line, substitute=substitute))
     return self
 
   def IsEmpty(self):
     """Returns True if the Code object is empty.
     """
     return not bool(self._code)
 
-  def Concat(self, obj):
+  def Concat(self, obj, new_line=True):
     """Concatenate another Code object onto this one. Trailing whitespace is
     stripped.
 
     Appends the code at the current indent level. Will fail if there are any
     un-interpolated format specifiers eg %s, %(something)s which helps
     isolate any strings that haven't been substituted.
     """
     if not isinstance(obj, Code):
       raise TypeError(type(obj))
     assert self is not obj
+    if not obj._code:
+      return self
+
     for line in obj._code:
       try:
         # line % () will fail if any substitution tokens are left in line
         if line.substitute:
           line.value %= ()
       except TypeError:
         raise TypeError('Unsubstituted value when concatting\n' + line.value)
       except ValueError:
         raise ValueError('Stray % character when concatting\n' + line.value)
+    first_line = obj._code.pop(0)
+    self.Append(first_line.value, first_line.substitute, new_line=new_line)
+    for line in obj._code:
       self.Append(line.value, line.substitute)
 
     return self
 
   def Cblock(self, code):
     """Concatenates another Code object |code| onto this one followed by a
     blank line, if |code| is non-empty."""
     if not code.IsEmpty():
       self.Concat(code).Append()
     return self
 
-  def Sblock(self, line=None):
+  def Sblock(self, line=None, line_prefix=None, new_line=True):

[Tyler Breisacher (Chromium), 2015/03/27 22:52:18]

Ugh. Let's not do it in this CL but let's rename these to StartBlock and
EndBlock at some point.

[Devlin, 2015/03/27 23:04:09]

SGTM. :)

     """Starts a code block.
 
-    Appends a line of code and then increases the indent level.
+    Appends a line of code and then increases the indent level. If |line_prefix|
+    is present, it will be treated as the extra prefix for the code block.
+    Otherwise, the prefix will be the default indent level.
     """
     if line is not None:
-      self.Append(line)
-    self._indent_level += self._indent_size
+      self.Append(line, new_line=new_line)
+    self._line_prefixes.append(
+        line_prefix if line_prefix else ' ' * self._indent_size)

[Tyler Breisacher (Chromium), 2015/03/27 23:22:32]

I'm certainly not a Pythonista but I think you can write this as

  line_prefix or ' ' * self._indent_size

[Devlin, 2015/03/27 23:39:46]

Ah, right.  Keep forgetting that. :)  Done.

     return self
 
   def Eblock(self, line=None):
     """Ends a code block by decreasing and then appending a line (or a blank
     line if not given).
     """
     # TODO(calamity): Decide if type checking is necessary
     #if not isinstance(line, basestring):
     #  raise TypeError
-    self._indent_level -= self._indent_size
+    self._line_prefixes.pop()
     if line is not None:
       self.Append(line)
     return self
 
-  def Comment(self, comment, comment_prefix='// ', wrap_indent=0):
+  def Comment(self, comment, comment_prefix='// ',
+              wrap_indent=0, new_line=True):
     """Adds the given string as a comment.
 
     Will split the comment if it's too long. Use mainly for variable length
     comments. Otherwise just use code.Append('// ...') for comments.
 
     Unaffected by code.Substitute().
     """
     # Helper function to trim a comment to the maximum length, and return one
     # line and the remainder of the comment.
     def trim_comment(comment, max_len):
       if len(comment) <= max_len:
         return comment, ''
       last_space = comment.rfind(' ', 0, max_len + 1)
       if last_space != -1:
         line = comment[0:last_space]
         comment = comment[last_space + 1:]
       else:
         line = comment[0:max_len]
         comment = comment[max_len:]
       return line, comment
 
     # First line has the full maximum length.
-    max_len = self._comment_length - self._indent_level - len(comment_prefix)
+    if not new_line and self._code:
+      max_len = self._comment_length - len(self._code[-1].value) - 1
+    else:
+      max_len = (self._comment_length - len(''.join(self._line_prefixes)) -
+                 len(comment_prefix))
     line, comment = trim_comment(comment, max_len)
-    self.Append(comment_prefix + line, substitute=False)
+    self.Append(comment_prefix + line, substitute=False, new_line=new_line)
 
     # Any subsequent lines be subject to the wrap indent.
-    max_len = max_len - wrap_indent
+    max_len = (self._comment_length - len(''.join(self._line_prefixes)) -
+               len(comment_prefix) - wrap_indent)
     while len(comment):
       line, comment = trim_comment(comment, max_len)
       self.Append(comment_prefix + (' ' * wrap_indent) + line, substitute=False)
 
     return self
 
   def Substitute(self, d):
     """Goes through each line and interpolates using the given dict.
 
     Raises type error if passed something that isn't a dict
@@ skipping 20 matching lines @@
     """
     return '\n'.join([l.value for l in self._code])
 
 
 class Line(object):
   """A line of code.
   """
   def __init__(self, value, substitute=True):
     self.value = value
     self.substitute = substitute