json_schema_compiler: any, additionalProperties, functions on types

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._substitute = []
     self._indent_level = 0
     self._indent_size = indent_size
     self._comment_length = comment_length
 
-  def Append(self, line=''):
+  def Append(self, line='', substitute=True):
     """Appends a line of code at the current indent level or just a newline if
     line is not specified. Trailing whitespace is stripped.
+
+    substitute: indicated whether this line should be affected by
+    code.Substitute().
     """
+    self._substitute.append(substitute)
     self._code.append(((' ' * self._indent_level) + line).rstrip())
     return self
 
   def IsEmpty(self):
     """Returns True if the Code object is empty.
     """
     return not bool(self._code)
 
   def Concat(self, obj):
     """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
-    for line in obj._code:
+    for substitute, line in zip(obj._substitute, obj._code):

[Yoyo Zhou, 2012/02/28 22:23:41]

itertools.izip?

[calamity, 2012/03/01 04:47:09]

Done.

       try:
         # line % () will fail if any substitution tokens are left in line
-        self._code.append(((' ' * self._indent_level) + line % ()).rstrip())
+        if substitute:
+          line %= ()
       except TypeError:
         raise TypeError('Unsubstituted value when concatting\n' + line)
+      except ValueError:
+        raise ValueError('Stray % character when concatting\n' + line)
+      self.Append(line, substitute)
 
     return self
 
   def Sblock(self, line=''):
     """Starts a code block.
 
     Appends a line of code and then increases the indent level.
     """
     self.Append(line)
     self._indent_level += self._indent_size
     return self
 
   def Eblock(self, line=''):
     """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.Append(line)
     return self
 
-  # TODO(calamity): Make comment its own class or something and Render at
-  # self.Render() time
   def Comment(self, comment):
     """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().

[Yoyo Zhou, 2012/02/28 22:23:41]

You could make substitute a parameter to this function too, if that could be
useful.

[not at google - send to devlin, 2012/02/28 22:41:17]

Might a better solution be to just escape all % characters as %% ? Nothing else
woud need to change, then.

You should also say in the documentation that string substitutions are
automatically escaped, therefore not supported in comments.

[calamity, 2012/03/01 04:47:09]

Escaping is a little more tricky that that. Since strings can get substituted
after a Concat, we need to know which lines are comments so we don't escape
them.

[calamity, 2012/03/01 04:47:09]

I think it's safer to disallow that. The problem here was % characters in
descriptions and I'd hate for someone else to accidentally allow this and
scratch their heads over why there's an error.

[not at google - send to devlin, 2012/03/01 07:09:37]

Ah, I see the problem.  Cool.

I think that parallel lists (as opposed to a mini class/struct thing) is a bit
unfortunate, but not a biggie. Well... actually that would be kind of nice I
think. You could store the line and a substitute flag, and after substituting
always set that to false (and if it's a comment then start off as false). And
then you wouldn't need that parallel list / zip / etc nastiness.  Eh, something
to consider if you want.

[calamity, 2012/03/01 23:58:48]

Done.

     """
     comment_symbol = '// '
     max_len = self._comment_length - self._indent_level - len(comment_symbol)
     while len(comment) >= max_len:
       line = comment[0:max_len]
       last_space = line.rfind(' ')
       if last_space != -1:
         line = line[0:last_space]
         comment = comment[last_space + 1:]
       else:
         comment = comment[max_len:]
-      self.Append(comment_symbol + line)
-    self.Append(comment_symbol + comment)
+      self.Append(comment_symbol + line, substitute=False)
+    self.Append(comment_symbol + comment, 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
 
     Use for long pieces of code using interpolation with the same variables
     repeatedly. This will reduce code and allow for named placeholders which
     are more clear.
     """
     if not isinstance(d, dict):
       raise TypeError('Passed argument is not a dictionary: ' + d)
     for i, line in enumerate(self._code):
-      # Only need to check %s because arg is a dict and python will allow
-      # '%s %(named)s' but just about nothing else
-      if '%s' in self._code[i] or '%r' in self._code[i]:
-        raise TypeError('"%s" or "%r" found in substitution. '
-                        'Named arguments only. Use "%" to escape')
-      self._code[i] = line % d
+      if self._substitute[i]:
+        # Only need to check %s because arg is a dict and python will allow
+        # '%s %(named)s' but just about nothing else
+        if '%s' in self._code[i] or '%r' in self._code[i]:
+          raise TypeError('"%s" or "%r" found in substitution. '
+                          'Named arguments only. Use "%" to escape')
+        self._code[i] = line % d
     return self
 
   def Render(self):
     """Renders Code as a string.
     """
     return '\n'.join(self._code)