def testGetCppTypeIncludedRef(self):
m = model.Model()
m.AddNamespace(self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEquals(
'std::vector<tabs::Tab>',
manager.GetCppType(
self.windows.types['Window'].properties['tabs'].type_))
def testGenerateIncludesAndForwardDeclarations(self):
m = model.Model()
m.AddNamespace(self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEquals('', manager.GenerateIncludes().Render())
self.assertEquals('#include "path/to/tabs.h"',
manager.GenerateIncludes(include_soft=True).Render())
self.assertEquals(
'namespace tabs {\n'
'struct Tab;\n'
'} // namespace tabs',
manager.GenerateForwardDeclarations().Render())
m = model.Model()
m.AddNamespace(
self.windows_json[0],
'path/to/windows.json',
environment=CppNamespaceEnvironment('foo::bar::%(namespace)s'))
m.AddNamespace(
self.tabs_json[0],
'path/to/tabs.json',
environment=CppNamespaceEnvironment('foo::bar::%(namespace)s'))
manager = CppTypeGenerator(m, _FakeSchemaLoader(m))
self.assertEquals(
'namespace foo {\n'
'namespace bar {\n'
'namespace tabs {\n'
'struct Tab;\n'
'} // namespace tabs\n'
'} // namespace bar\n'
'} // namespace foo',
manager.GenerateForwardDeclarations().Render())
manager = CppTypeGenerator(self.models.get('permissions'),
_FakeSchemaLoader(m))
self.assertEquals('', manager.GenerateIncludes().Render())
self.assertEquals('', manager.GenerateIncludes().Render())
self.assertEquals('', manager.GenerateForwardDeclarations().Render())
manager = CppTypeGenerator(self.models.get('content_settings'),
_FakeSchemaLoader(m))
self.assertEquals('', manager.GenerateIncludes().Render())
def testHardIncludesForEnumArrays(self):
"""Tests that enums in arrays generate hard includes. Note that it's
important to use a separate file (cross_enums_array) here to isolate the
test case so that other types don't cause the hard-dependency.
"""
m = model.Model()
m.AddNamespace(self.crossref_enums_json[0],
'path/to/crossref_enums_array.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
m.AddNamespace(self.simple_api_json[0],
'path/to/simple_api.json',
environment=CppNamespaceEnvironment('%(namespace)s'))
manager = CppTypeGenerator(self.models.get('crossref_enums_array'),
_FakeSchemaLoader(m))
self.assertEquals('#include "path/to/simple_api.h"',
manager.GenerateIncludes().Render())
def ResolveNamespace(self, full_namespace):
filenames = GenerateFilenames(full_namespace)
for path, cpp_namespace in self._include_rules:
for filename in reversed(filenames):
filepath = os.path.join(path, filename)
if os.path.exists(os.path.join(self._root, filepath)):
return Model().AddNamespace(
self.LoadSchema(filepath)[0],
filepath,
environment=CppNamespaceEnvironment(cpp_namespace))
return None
def ResolveNamespace(self, full_namespace):
'''Returns the model.Namespace object associated with the |full_namespace|,
or None if one can't be found.
'''
filenames = _GenerateFilenames(full_namespace)
for path, cpp_namespace in self._include_rules:
cpp_namespace_environment = None
if cpp_namespace:
cpp_namespace_environment = CppNamespaceEnvironment(cpp_namespace)
for filename in reversed(filenames):
filepath = os.path.join(path, filename);
if os.path.exists(os.path.join(self._root, filepath)):
schema = SchemaLoader(self._root).LoadSchema(filepath)[0]
return Model().AddNamespace(
schema,
filepath,
environment=cpp_namespace_environment)
return None
def GenerateSchema(generator_name,
file_paths,
root,
destdir,
cpp_namespace_pattern,
bundle_name,
impl_dir,
include_rules):
# Merge the source files into a single list of schemas.
api_defs = []
for file_path in file_paths:
schema = os.path.relpath(file_path, root)
api_def = SchemaLoader(root).LoadSchema(schema)
# If compiling the C++ model code, delete 'nocompile' nodes.
if generator_name == 'cpp':
api_def = json_schema.DeleteNodes(api_def, 'nocompile')
# Delete all 'nodefine' nodes. They are only for documentation.
api_def = json_schema.DeleteNodes(api_def, 'nodefine')
api_defs.extend(api_def)
api_model = Model(allow_inline_enums=False)
# For single-schema compilation make sure that the first (i.e. only) schema
# is the default one.
default_namespace = None
# If we have files from multiple source paths, we'll use the common parent
# path as the source directory.
src_path = None
# Load the actual namespaces into the model.
for target_namespace, file_path in zip(api_defs, file_paths):
relpath = os.path.relpath(os.path.normpath(file_path), root)
namespace = api_model.AddNamespace(target_namespace,
relpath,
include_compiler_options=True,
environment=CppNamespaceEnvironment(
cpp_namespace_pattern))
if default_namespace is None:
default_namespace = namespace
if src_path is None:
src_path = namespace.source_file_dir
else:
src_path = os.path.commonprefix((src_path, namespace.source_file_dir))
_, filename = os.path.split(file_path)
filename_base, _ = os.path.splitext(filename)
# Construct the type generator with all the namespaces in this model.
schema_dir = os.path.dirname(os.path.relpath(file_paths[0], root))
namespace_resolver = NamespaceResolver(root, schema_dir,
include_rules, cpp_namespace_pattern)
type_generator = CppTypeGenerator(api_model,
namespace_resolver,
default_namespace)
if generator_name in ('cpp-bundle-registration', 'cpp-bundle-schema'):
cpp_bundle_generator = CppBundleGenerator(root,
api_model,
api_defs,
type_generator,
cpp_namespace_pattern,
bundle_name,
src_path,
impl_dir)
if generator_name == 'cpp-bundle-registration':
generators = [
('generated_api_registration.cc',
cpp_bundle_generator.api_cc_generator),
('generated_api_registration.h', cpp_bundle_generator.api_h_generator),
]
elif generator_name == 'cpp-bundle-schema':
generators = [
('generated_schemas.cc', cpp_bundle_generator.schemas_cc_generator),
('generated_schemas.h', cpp_bundle_generator.schemas_h_generator)
]
elif generator_name == 'cpp':
cpp_generator = CppGenerator(type_generator)
generators = [
('%s.h' % filename_base, cpp_generator.h_generator),
('%s.cc' % filename_base, cpp_generator.cc_generator)
]
elif generator_name == 'externs':
generators = [
('%s_externs.js' % namespace.unix_name, JsExternsGenerator())
]
elif generator_name == 'interface':
generators = [
('%s_interface.js' % namespace.unix_name, JsInterfaceGenerator())
]
else:
raise Exception('Unrecognised generator %s' % generator_name)
output_code = []
for filename, generator in generators:
code = generator.Generate(namespace).Render()
if destdir:
if generator_name == 'cpp-bundle-registration':
# Function registrations must be output to impl_dir, since they link in
# API implementations.
output_dir = os.path.join(destdir, impl_dir)
else:
output_dir = os.path.join(destdir, src_path)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
with open(os.path.join(output_dir, filename), 'w') as f:
f.write(code)
# If multiple files are being output, add the filename for each file.
if len(generators) > 1:
output_code += [filename, '', code, '']
else:
output_code += [code]
return '\n'.join(output_code)
