Clean up JSON Schema Compiler.

tools/json_schema_compiler/cpp_bundle_generator.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.
 
 import code
 import cpp_util
 from model import Platforms
 from schema_util import CapitalizeFirstLetter
 from schema_util import JsFunctionNameToClassName
 
@@ skipping 13 matching lines @@
       # Some schemas actually have properties called "description", so only
       # remove descriptions that have string values.
       if key == 'description' and isinstance(value, basestring):
         continue
       result[key] = _RemoveDescriptions(value)
     return result
   if isinstance(node, list):
     return [_RemoveDescriptions(v) for v in node]
   return node
 
+
 class CppBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
   def __init__(self, root, model, api_defs, cpp_type_generator, cpp_namespace):
-    self._root = root;
+    self._root = root
     self._model = model
     self._api_defs = api_defs
     self._cpp_type_generator = cpp_type_generator
     self._cpp_namespace = cpp_namespace
 
     self.api_cc_generator = _APICCGenerator(self)
     self.api_h_generator = _APIHGenerator(self)
     self.schemas_cc_generator = _SchemasCCGenerator(self)
     self.schemas_h_generator = _SchemasHGenerator(self)
 
@@ skipping 70 matching lines @@
           namespace_types_name = JsFunctionNameToClassName(
                 namespace.name, type_.name)
           c.Concat(self._GenerateRegisterFunctions(namespace_types_name,
                                                    function))
 
       if namespace_ifdefs is not None:
         c.Append("#endif  // %s" % namespace_ifdefs, indent_level=0)
     c.Eblock("}")
     return c
 
+
 class _APIHGenerator(object):
   """Generates the header for API registration / declaration"""
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
   def Generate(self, namespace):
     c = code.Code()
 
     c.Append('#include <string>')
     c.Append()
     c.Append('#include "base/basictypes.h"')
     c.Append()
     c.Append("class ExtensionFunctionRegistry;")
     c.Append()
     c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
     c.Append('class GeneratedFunctionRegistry {')
     c.Sblock(' public:')
     c.Append('static void RegisterAll('
                  'ExtensionFunctionRegistry* registry);')
-    c.Eblock('};');
+    c.Eblock('};')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     return self._bundle._GenerateHeader('generated_api', c)
 
+
 class _APICCGenerator(object):
   """Generates a code.Code object for the generated API .cc file"""
 
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
   def Generate(self, namespace):
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
@@ skipping 27 matching lines @@
                  '"chrome/browser/extensions/extension_function_registry.h"')
     c.Append()
     c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
     c.Concat(self._bundle._GenerateFunctionRegistryRegisterAll())
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     c.Append()
     return c
 
+
 class _SchemasHGenerator(object):
   """Generates a code.Code object for the generated schemas .h file"""
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
   def Generate(self, namespace):
     c = code.Code()
     c.Append('#include <map>')
     c.Append('#include <string>')
-    c.Append();
+    c.Append()
     c.Append('#include "base/strings/string_piece.h"')
     c.Append()
     c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
     c.Append('class GeneratedSchemas {')
     c.Sblock(' public:')
     c.Append('// Determines if schema named |name| is generated.')
     c.Append('static bool IsGenerated(std::string name);')
     c.Append()
     c.Append('// Gets the API schema named |name|.')
     c.Append('static base::StringPiece Get(const std::string& name);')
-    c.Eblock('};');
+    c.Eblock('};')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     return self._bundle._GenerateHeader('generated_schemas', c)
 
+
 def _FormatNameAsConstant(name):
   """Formats a name to be a C++ constant of the form kConstantName"""
   name = '%s%s' % (name[0].upper(), name[1:])
   return 'k%s' % re.sub('_[a-z]',
                         lambda m: m.group(0)[1].upper(),
                         name.replace('.', '_'))
 
+
 class _SchemasCCGenerator(object):
   """Generates a code.Code object for the generated schemas .cc file"""
 
   def __init__(self, cpp_bundle):
     self._bundle = cpp_bundle
 
   def Generate(self, namespace):
     c = code.Code()
     c.Append(cpp_util.CHROMIUM_LICENSE)
     c.Append()
@@ skipping 15 matching lines @@
           (_FormatNameAsConstant(namespace.name), json_content))
     c.Append('}')
     c.Concat(cpp_util.OpenNamespace(self._bundle._cpp_namespace))
     c.Append()
     c.Sblock('struct Static {')
     c.Sblock('Static() {')
     for api in self._bundle._api_defs:
       namespace = self._bundle._model.namespaces[api.get('namespace')]
       c.Append('schemas["%s"] = %s;' % (namespace.name,
                                         _FormatNameAsConstant(namespace.name)))
-    c.Eblock('}');
+    c.Eblock('}')
     c.Append()
     c.Append('std::map<std::string, const char*> schemas;')
-    c.Eblock('};');
+    c.Eblock('};')
     c.Append()
     c.Append('base::LazyInstance<Static> g_lazy_instance;')
     c.Append()
     c.Append('// static')
     c.Sblock('base::StringPiece GeneratedSchemas::Get('
                   'const std::string& name) {')
     c.Append('return IsGenerated(name) ? '
              'g_lazy_instance.Get().schemas[name] : "";')
     c.Eblock('}')
     c.Append()
     c.Append('// static')
     c.Sblock('bool GeneratedSchemas::IsGenerated(std::string name) {')
     c.Append('return g_lazy_instance.Get().schemas.count(name) > 0;')
     c.Eblock('}')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     c.Append()
     return c