Initial code generation for features.

tools/json_schema_compiler/features_compiler.py

Index: tools/json_schema_compiler/features_compiler.py
diff --git a/tools/json_schema_compiler/features_compiler.py b/tools/json_schema_compiler/features_compiler.py
new file mode 100755
index 0000000000000000000000000000000000000000..1a0b6f72a125818e150c66baa419c7216e3e09d5
--- /dev/null
+++ b/tools/json_schema_compiler/features_compiler.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# 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.
+"""Generator for C++ permissions from permission json files.
+
+Usage example:
+  features_compiler.py --destdir gen --root /home/Work/src _permissions.json
+"""
+
+import optparse
+import os
+import sys
+
+import json_schema
+from schema_loader import SchemaLoader
+from features_cc_generator import CCGenerator
+from features_h_generator import HGenerator
+from model import Feature
+
+
+def GenerateSchema(filenames, root, destdir):

[not at google - send to devlin, 2013/09/12 16:20:43]

Private, so _GenerateSchema.

Add a

'''Docstring.
'''

[dhnishi (use Chromium), 2013/09/13 17:36:42]

Done.

+  # Load in the feature permissions from the JSON file.
+  schema_loader = SchemaLoader(os.path.dirname(os.path.relpath(
+      os.path.normpath(filenames[0]), root)), True)

[not at google - send to devlin, 2013/09/12 16:20:43]

what is True here? make it a named parameter if anything...

[dhnishi (use Chromium), 2013/09/13 17:36:42]

The SchemaLoader by default doesn't allow multiple schemas to be loaded. We need
this for the features gen, so I added a flag to allow it to happen.

+  schema = os.path.normpath(filenames[0])

[not at google - send to devlin, 2013/09/12 16:20:43]

pass schema into this function rather than filenames (and it makes sense to call
it filename). also I don't know what advantage the os.path.normpath has.

[dhnishi (use Chromium), 2013/09/13 17:36:42]

If the path is coming in an oddball way with unnecessary ".."s and such,
normpath strips them.

Also, done. |schema| is now passed in, rather than normpathing twice.

[not at google - send to devlin, 2013/09/13 21:37:51]

Yeah - though I mean more like do things actually break if this happens. But,
not a big point. Cleaner sounds nice.

+  schema_filename, schema_extension = os.path.splitext(schema)

[not at google - send to devlin, 2013/09/12 16:20:43]

schema_extension isn't used, so substitute _

[dhnishi (use Chromium), 2013/09/13 17:36:42]

Done.

+  feature_defs = schema_loader.LoadSchema(schema)
+
+  # Generate a list of the features defined and a list of their models.
+  feature_list = []
+  for feature_def, feature_dict in feature_defs.iteritems():
+    if type(feature_dict) is not list:

[not at google - send to devlin, 2013/09/12 16:20:43]

a bit odd to be comparing a type of a variable called "feature_dict" to a list.

anyhow, typically you would use isinstance(feature_dict, dict): here.

[dhnishi (use Chromium), 2013/09/13 17:36:42]

I'm having difficulty thinking of a good name for it, since it's sometimes a
list and sometimes a dict. I switched it over to the generic name |feature| for
now, but I'll keep thinking about it.

Done.

+      feature_list.append(Feature(feature_def, feature_dict, schema))
+    else:
+      ## The dict may contain list of features, not a single feature.
+      for single_def in feature_dict:
+        feature_list.append(Feature(feature_def, single_def, schema))

[not at google - send to devlin, 2013/09/12 16:20:43]

here:

feature_list += [Feature(feature_def, single_def, schema)
                 for single_def in feature_dict]

[dhnishi (use Chromium), 2013/09/13 17:36:42]

That looks cleaner. Done.

+
+  source_file_dir, source_file_filename = os.path.split(schema)
+  relpath = os.path.relpath(os.path.normpath(source_file_dir), root)
+  full_path = relpath + "/%s" % schema

[not at google - send to devlin, 2013/09/12 16:20:43]

os.path.join(relpath, schema)

[dhnishi (use Chromium), 2013/09/13 17:36:42]

Done.

+
+  generators = [
+    ('%s.cc' % schema_filename, CCGenerator()),
+    ('%s.h' % schema_filename, HGenerator())
+  ]
+
+  # Generate and output the code for all features.
+  output_code = []
+  for filename, generator in generators:
+    code = generator.Generate(feature_list, full_path).Render()
+    if destdir:
+      with open(os.path.join(destdir, relpath,
+          filename), 'w') as f:
+        f.write(code)
+    output_code += [filename, '', code, '']
+
+  return '\n'.join(output_code)
+
+
+if __name__ == '__main__':
+  parser = optparse.OptionParser(
+      description='Generates a C++ features model from JSON schema',
+      usage='usage: %prog [option]... schema')
+  parser.add_option('-r', '--root', default='.',
+      help='logical include root directory. Path to schema files from specified'
+      'dir will be the include path.')
+  parser.add_option('-d', '--destdir',
+      help='root directory to output generated files.')
+  (opts, filenames) = parser.parse_args()
+
+  if not filenames:
+    sys.exit(0) # This is OK as a no-op

[not at google - send to devlin, 2013/09/12 16:20:43]

I don't think this make sense here

[dhnishi (use Chromium), 2013/09/13 17:36:42]

I replaced it with a raise Exception, since it doesn't make much sense for the
feature compiler to be called w/o any files to compile from.

+
+  # Only one file is currently specified.
+  if len(filenames) > 1:
+    raise Exception(
+        "Only one file is allowed (for now).")

[not at google - send to devlin, 2013/09/12 16:20:43]

single line

[dhnishi (use Chromium), 2013/09/13 17:36:42]

Done.

+
+  result = GenerateSchema(filenames, opts.root, opts.destdir)
+  if not opts.destdir:
+    print result