def _can_generate(schema, language, output_dir):
"""Verifies whether the generation options are in a state such that generation can occur.
:param module schema: Ontology schema definition.
:param str language: Target programming language.
:param str io_dir: Target I/O directory.
:returns: True if generation can occur, False otherwise.
:rtype: bool
"""
if not language in _HANDLERS:
err = "Programming language is unsupported [{}]. Supported languages are {}."
err = err.format(language, _HANDLERS.keys())
raise ValueError(err)
if not os.path.exists(output_dir):
raise IOError("Output directory does not exist [{0}].".format(output_dir))
errors = validate_schema(schema)
if errors:
utils.log("-------------------------------------------------------------------")
for error in errors:
utils.log("VALIDATION ERROR :: {0}".format(error))
return False
return True
def generate(schema, language, io_dir):
"""Generates code.
:param module schema: Ontology schema definition.
:param str language: Target programming language.
:param str io_dir: Target I/O directory.
"""
if not _can_generate(schema, language, io_dir):
return
_log_start(schema, language, io_dir)
# Initialise ontology.
ontology = create_ontology(schema)
utils.log("ONTOLOGY :: {0} (packages={1}, classes={2}, enums={3})".format(
ontology, len(ontology.packages), len(ontology.classes), len(ontology.enums)))
# Apply language specific pre-generator formatter.
try:
formatter = _HANDLERS[language].UTILS.format
except AttributeError:
pass
else:
formatter(ontology)
utils.log("ONTOLOGY :: formatted for {0}".format(language))
# Invoke language specific generators.
for generator in _HANDLERS[language].GENERATORS:
func = _generate_from_template if isinstance(generator, str) else _generate_from_parser
func(GeneratorContext(generator, ontology, language, io_dir), generator)
_log_end()
def _set_base_classes(ontology):
"""Sets base classes.
"""
for cls in [c for c in ontology.classes if c.base]:
base_cls = ontology.get_type(cls.base)
if base_cls:
cls.base = base_cls
else:
msg = "Base class not found :: class = {0}.{1} :: base = {2}"
msg = msg.format(cls.package, cls, cls.base)
utils.log(msg)
def _set_base_classes(ontology):
"""Sets base classes.
"""
for cls in [c for c in ontology.classes if c.base]:
base_cls = ontology.get_type(cls.base)
if base_cls:
cls.base = base_cls
else:
msg = "Base class not found :: class = {0}.{1} :: base = {2}"
msg = msg.format(cls.package, cls, cls.base)
utils.log(msg)
def _generate_from_template(ctx, template):
"""Generates code from a tornado template.
"""
lu = _HANDLERS[ctx.language].UTILS
utils.log("GENERATOR = {0} :: generation begins".format(ctx.key))
code = ctx.get_code(template, lu)
if code:
gu.write_file(gu.format_code(ctx, code),
lu.get_ontology_directory(ctx),
lu.get_module_file_name(template.split('.')[0]))
utils.log("GENERATOR = {0} :: generation complete".format(ctx.key))
def _log_start(schema, language, io_dir):
"""Informs user that generation is about to begin.
"""
utils.log("Welcome to the ES-DOC meta-programming code generator !")
utils.log("GENERATION OPTION : ontology schema = {0} v{1}".format(schema.NAME, schema.VERSION))
utils.log("GENERATION OPTION : programming language = {0}".format(language))
utils.log("GENERATION OPTION : output directory = {0}".format(io_dir))
def _generate_from_parser(ctx, parser_type):
"""Generates code from an ontology parser.
"""
parser = parser_type()
if not parser.is_required(ctx):
utils.log("GENERATOR = {0} :: generation skipped".format(ctx.key))
else:
utils.log("GENERATOR = {0} :: generation begins".format(ctx.key))
parser.execute(ctx)
for code, dir_, fpath in ctx.code:
gu.write_file(gu.format_code(ctx, code), dir_, fpath)
utils.log("GENERATOR = {0} :: generation complete".format(ctx.key))
def _log_end():
"""Informs user that generation is complete.
"""
utils.log("Thank you for using the ES-DOC code generator")