def _ShowCompiledFile(self, parsed_url, head, body):
"""Show the compiled version of a json file given the path to the compiled
file.
"""
api_model = model.Model()
request_path = self._GetRequestPath(parsed_url)
(file_root, file_ext) = os.path.splitext(request_path)
(filedir, filename) = os.path.split(file_root)
json_file_path = os.path.normpath(file_root + '.json')
try:
# Get main json file
api_defs = json_schema.Load(json_file_path)
namespace = api_model.AddNamespace(api_defs[0], json_file_path)
type_generator = cpp_type_generator.CppTypeGenerator(
'previewserver::api', namespace, namespace.unix_name)
# Get json file depedencies
for dependency in api_defs[0].get('dependencies', []):
json_file_path = os.path.join(filedir, dependency + '.json')
api_defs = json_schema.Load(json_file_path)
referenced_namespace = api_model.AddNamespace(
api_defs[0], json_file_path)
if referenced_namespace:
type_generator.AddNamespace(
referenced_namespace,
cpp_util.Classname(referenced_namespace.name).lower())
# Generate code
if file_ext == '.h':
cpp_code = (h_generator.HGenerator(
namespace, type_generator).Generate().Render())
elif file_ext == '.cc':
cpp_code = (cc_generator.CCGenerator(
namespace, type_generator).Generate().Render())
else:
self.send_error(404, "File not found: %s" % request_path)
return
# Do highlighting on the generated code
(highlighter_param,
style_param) = self._GetHighlighterParams(parsed_url)
head.Append('<style>' +
self.server.highlighters[highlighter_param].GetCSS(
style_param) + '</style>')
body.Append(
self.server.highlighters[highlighter_param].GetCodeElement(
cpp_code, style_param))
except IOError:
self.send_error(404, "File not found: %s" % request_path)
return
except (TypeError, KeyError, AttributeError, AssertionError,
NotImplementedError) as error:
body.Append('<pre>')
body.Append('compiler error: ' + str(error))
body.Append('Check server log for more details')
body.Append('</pre>')
raise
def _createCppBundleGenerator(file_path):
json_object = json_schema.Load(file_path)
model = Model()
model.AddNamespace(json_object[0], file_path)
cpp_bundle_generator = CppBundleGenerator(
None, model, None, None, 'generated_api_schemas',
None, None, None)
return (cpp_bundle_generator, model)
def load_schema(schema):
schema_filename, schema_extension = os.path.splitext(schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema)
else:
sys.exit("Did not recognize file extension %s for schema %s" %
(schema_extension, schema))
return api_defs
def LoadSchema(self, schema):
schema_filename, schema_extension = os.path.splitext(schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
if len(api_defs) != 1:
sys.exit('File %s has multiple schemas. Files are only allowed to contain'
'a single schema.' % schema)
return api_defs
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
with the full path relative to the root.'''
schema_filename, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._root, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
return api_defs
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
with the full path relative to the root.'''
_, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._root, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
# TODO(devlin): This returns a list. Does it need to? Is it ever > 1?
return api_defs
def LoadSchema(self, schema):
'''Load a schema definition. The schema parameter must be a file name
without any path component - the file is loaded from the path defined by
the real_path argument passed to the constructor.'''
schema_filename, schema_extension = os.path.splitext(schema)
schema_path = os.path.join(self._real_path, schema)
if schema_extension == '.json':
api_defs = json_schema.Load(schema_path)
elif schema_extension == '.idl':
api_defs = idl_schema.Load(schema_path)
else:
sys.exit('Did not recognize file extension %s for schema %s' %
(schema_extension, schema))
return api_defs
def handle_single_schema(filename, dest_dir, root, root_namespace):
schema = os.path.normpath(filename)
schema_filename, schema_extension = os.path.splitext(schema)
path, short_filename = os.path.split(schema_filename)
api_defs = json_schema.DeleteNocompileNodes(load_schema(schema))
api_model = model.Model()
for target_namespace in api_defs:
referenced_schemas = target_namespace.get('dependencies', [])
# Load type dependencies into the model.
# TODO(miket): do we need this in IDL?
for referenced_schema in referenced_schemas:
referenced_schema_path = os.path.join(
os.path.dirname(schema), referenced_schema + '.json')
referenced_api_defs = json_schema.Load(referenced_schema_path)
for namespace in referenced_api_defs:
api_model.AddNamespace(namespace,
os.path.relpath(referenced_schema_path, opts.root))
# Gets the relative path from opts.root to the schema to correctly determine
# the include path.
relpath = os.path.relpath(schema, opts.root)
namespace = api_model.AddNamespace(target_namespace, relpath)
if not namespace:
continue
if short_filename != namespace.unix_name:
sys.exit("Filename %s is illegal. Name files using unix_hacker style." %
filename)
# The output filename must match the input filename for gyp to deal with it
# properly.
out_file = namespace.unix_name
type_generator = cpp_type_generator.CppTypeGenerator(
root_namespace, namespace, namespace.unix_name)
for referenced_namespace in api_model.namespaces.values():
if referenced_namespace == namespace:
continue
type_generator.AddNamespace(
referenced_namespace,
referenced_namespace.unix_name)
h_code = (h_generator.HGenerator(namespace, type_generator)
.Generate().Render())
cc_code = (cc_generator.CCGenerator(namespace, type_generator)
.Generate().Render())
if dest_dir:
with open(
os.path.join(dest_dir, namespace.source_file_dir, out_file + '.cc'),
'w') as cc_file:
cc_file.write(cc_code)
with open(
os.path.join(dest_dir, namespace.source_file_dir, out_file + '.h'),
'w') as h_file:
h_file.write(h_code)
else:
print '%s.h' % out_file
print
print h_code
print
print '%s.cc' % out_file
print
print cc_code
