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)