def MakeApiWithSchemas(schemas):
discovery_doc = {
'name': 'fake',
'version': 'v1',
'resources': {},
'schemas': schemas
}
api = Api(discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(FakeLanguageModel()))
return api
def testArrayOfArray(self):
class FakeLanguageModel(language_model.LanguageModel):
def GetCodeTypeFromDictionary(self, def_dict):
return def_dict.get('type')
def CodeTypeForArrayOf(self, s):
return 'Array[%s]' % s
discovery_doc = {
'name': 'fake',
'version': 'v1',
'schemas': {
'AdsenseReportsGenerateResponse': {
'id': 'AdsenseReportsGenerateResponse',
'type': 'object',
'properties': {
'basic': {
'type': 'string'
},
'simple_array': {
'type': 'array',
'items': {'type': 'string'}
},
'array_of_arrays': {
'type': 'array',
'items': {'type': 'array', 'items': {'type': 'string'}}
}
}
}
},
'resources': {}
}
api = Api(discovery_doc)
self.language_model = FakeLanguageModel()
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
response_schema = api._schemas.get('AdsenseReportsGenerateResponse')
self.assertTrue(response_schema)
prop = [prop for prop in response_schema.values['properties']
if prop.values['wireName'] == 'array_of_arrays']
self.assertTrue(len(prop) == 1)
prop = prop[0]
self.assertEquals('Array[Array[string]]', prop.codeType)
def testModuleOwnerDomainAndPackagePath(self):
self.discovery_doc['ownerDomain'] = 'toasty.com'
self.discovery_doc['packagePath'] = 'foo/BAR'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('com/toasty/foo/BAR/fake', api.values['module'].path)
def testModulePackagePath(self):
self.discovery_doc['packagePath'] = 'foo/BAR'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('com/google/foo/BAR/fake', api.values['module'].path)
def testModuleOwnerDomain(self):
self.discovery_doc['ownerDomain'] = 'foo.bar'
api = Api(self.discovery_doc)
api.VisitAll(lambda o: o.SetLanguageModel(self.language_model))
self.assertEquals('bar/foo/fake', api.values['module'].path)
def main(unused_argv):
if not FLAGS.discovery:
raise app.UsageError('You must specify --discovery')
if not (FLAGS.output_dir or FLAGS.output_file):
raise app.UsageError(
'You must specify one of --output_dir or --output_file')
if not FLAGS.templates:
raise app.UsageError('You must specify --templates')
f = open(FLAGS.discovery)
discovery_doc = json.loads(f.read())
f.close()
options = {
# Include other files needed to compile (e.g. base jar files)
'include_dependencies': False,
# Include the timestamp in the generated library
'include_timestamp': FLAGS.include_timestamp,
# Put API version in the package
'version_package': FLAGS.version_package,
}
if FLAGS.output_type == 'full':
options['include_dependencies'] = True
# try to determine what generator to use from the language variant.
language_variants = Targets().VariationsForLanguage(FLAGS.language)
if language_variants:
features = language_variants.GetFeatures(FLAGS.language_variant)
template_dir = features.template_dir
generator_name = features.get('generator', FLAGS.language)
else:
# Not described by targets.json. The template dir should just be down
# in the language specific folder
template_dir = os.path.join(os.path.dirname(__file__), 'languages',
FLAGS.language)
features = None
generator_name = FLAGS.language
# Instantiate the right code generator
lang_model = None
try:
if FLAGS.language == 'any':
api = Api(discovery_doc)
# TODO(user): A default language model should be built in to the
# templates
lang_model = language_model.DocumentingLanguageModel()
else:
generator_class = generator_lookup.GetGeneratorByLanguage(
generator_name)
generator_instance = generator_class(discovery_doc)
api = generator_instance.api
lang_model = generator_instance.language_model
except ValueError:
raise app.UsageError('Unsupported language option: %s' %
FLAGS.language)
api.VisitAll(lambda o: o.SetLanguageModel(lang_model))
gen = TemplateExpander(api, options=options)
if features:
gen.SetFeatures(features)
template_dir = os.path.join(template_dir, FLAGS.templates)
if not os.path.isdir(template_dir):
raise app.UsageError('Can not find template tree at: %s' %
template_dir)
gen.SetTemplateDir(template_dir)
# Get an output writer
package_writer = package_writer_foundry.GetPackageWriter(
output_dir=FLAGS.output_dir,
output_file=FLAGS.output_file,
output_format=FLAGS.output_format)
# do it
gen.GeneratePackage(package_writer)
package_writer.DoneWritingArchive()
return 0
