def versions_compatibility_validating(self):
"""version of generator script requires the same or lesser version of parser script.
if the parser script needs to fix a bug (and becomes, e.g. 1.0.1) and the generator script stays at 1.0.0.
As long as the generator script is the same or greater major version, it should be parsable.
This requires some level of backward compatibility. E.g. they have to be the same major version.
"""
regex = r'(\d+\.\d+).(\d)'
parser_origin = Parser().get_version
parser_split = re.findall(regex, parser_origin).pop()
generator_split = re.findall(regex, self.get_version).pop()
parser_major = float(parser_split[0])
generator_major = float(generator_split[0])
if parser_major > generator_major:
self.logger.critical(
'Generator (%s) requires the same or lesser version of Parser (%s)',
self.get_version, parser_origin)
sys.exit(1)
self.logger.info('Parser type: %s, version %s,\tGenerator version %s',
basename(getfile(Parser().__class__)), parser_origin,
self.get_version)
def main(source_xml='../MOBILE_API.xml'):
parser = Parser()
version = parser.get_version
print(version)
try:
interface = parser.parse(source_xml)
print(vars(interface))
return interface
except ParseError as error:
print(error)
def main(self):
"""
Main functions calls
"""
args = self.get_parser()
self.config_logging(args.verbose)
try:
interface = Parser().parse(args.source_xml, args.source_xsd)
except (ModelParseError, XmlParseError) as error1:
self.logger.error(error1)
sys.exit(1)
filtered = self.filter_pattern(interface, args.regex_pattern)
if not args.enums:
del filtered['enums']
if not args.structs:
del filtered['structs']
if not args.functions:
del filtered['functions']
if args.output_directory.is_file():
if args.skip:
self.logger.info('Skipping %s',
args.output_directory.as_posix())
return
if args.overwrite:
self.logger.info('Overriding %s',
args.output_directory.as_posix())
self.process(args.output_directory, filtered)
else:
while True:
try:
confirm = input(
'File already exists {}. Overwrite? Y/Enter = yes, N = no\n'
.format(args.output_directory.as_posix()))
if confirm.lower() == 'y' or not confirm:
self.logger.info('Overriding %s',
args.output_directory.as_posix())
self.process(args.output_directory, filtered)
break
if confirm.lower() == 'n':
self.logger.info('Skipping %s',
args.output_directory.as_posix())
break
except KeyboardInterrupt:
self.logger.info(
'\nThe user interrupted the execution of the program'
)
sys.exit(1)
else:
self.logger.info('Writing new %s',
args.output_directory.as_posix())
self.process(args.output_directory, filtered)
def parser(self, xml, xsd, pattern=None):
"""
Validate xml to match with xsd. Calling parsers to get Model from xml. If provided pattern, filtering Model.
:param xml: path to MOBILE_API.xml
:param xsd: path to MOBILE_API.xsd
:param pattern: regex-pattern from command-line arguments to filter element from initial Model
:return: initial Model
"""
self.logger.info(
'''Validating XML and generating model with following parameters:
Source xml : %s
Source xsd : %s''', xml, xsd)
try:
schema = XMLSchema(xsd)
if not schema.is_valid(xml):
raise GenerateError(schema.validate(xml))
interface = Parser().parse(xml)
except (InterfaceError, XMLSchemaError, GenerateError) as message1:
self.logger.critical('Invalid XML file content: %s, %s', xml,
message1)
sys.exit(1)
enum_names = tuple(interface.enums.keys())
struct_names = tuple(interface.structs.keys())
if pattern:
intermediate = OrderedDict()
intermediate.update({'params': interface.params})
for kind, content in vars(interface).items():
if kind == 'params':
continue
for name, item in content.items():
if re.match(pattern, item.name):
self.logger.info('%s/%s match with %s', kind,
item.name, pattern)
if kind in intermediate:
intermediate[kind].update({name: item})
else:
intermediate.update({kind: {name: item}})
interface = Interface(**intermediate)
self.logger.debug({
'enums':
tuple(interface.enums.keys()),
'structs':
tuple(interface.structs.keys()),
'functions':
tuple(
map(lambda i: i.function_id.name,
interface.functions.values())),
'params':
interface.params
})
return enum_names, struct_names, interface
def main(self):
"""
Entry point for parser and generator
:return: None
"""
args = self.get_parser()
self.config_logging(args.verbose)
self.logger.debug('parsed arguments:\n%s', pformat((vars(args))))
self.env = args.templates_directory
self.versions_compatibility_validating()
paths = self.get_paths()
try:
interface = Parser().parse(args.source_xml, args.source_xsd)
except ParseError as error1:
self.logger.error(error1)
sys.exit(1)
filtered, names = self.filter_pattern(interface, args.regex_pattern)
key_words = self.get_key_words()
mappings = self.get_mappings()
functions_transformer = FunctionsProducer(paths, names, mappings,
key_words)
if args.enums and filtered.enums:
directory = args.output_directory.joinpath(
self.evaluate_instance_directory(paths.enums_dir_name))
self.process(directory, args.skip, args.overwrite, filtered.enums,
EnumsProducer(paths, mappings, key_words))
if args.structs and filtered.structs:
directory = args.output_directory.joinpath(
self.evaluate_instance_directory(paths.structs_dir_name))
self.process(directory, args.skip, args.overwrite,
filtered.structs,
StructsProducer(paths, names, mappings, key_words))
if args.functions and filtered.functions:
directory = args.output_directory.joinpath(
self.evaluate_instance_directory(paths.functions_dir_name))
self.process(directory, args.skip, args.overwrite,
filtered.functions, functions_transformer)
self.process_function_name(
args.output_directory.joinpath(paths.rpc_creator),
paths.functions_dir_name, args.skip, args.overwrite,
interface.functions, functions_transformer,
mappings.get('functions', OrderedDict()))
async def parser(self, source_xml, source_xsd):
"""
Getting Model from source_xml, parsed and validated by module 'rpc_spec/InterfaceParser'
:param source_xml: path to xml file
:param source_xsd: path to xsd file
:return: Model, obtained from module 'rpc_spec/InterfaceParser'
"""
try:
start = datetime.now()
model = self.loop.run_in_executor(None, Parser().parse, source_xml, source_xsd)
model = await model
self.logger.debug('finish getting model in %s milisec,', (datetime.now() - start).microseconds / 1000.0)
return model
except ParseError as error1:
self.logger.error(error1)
sys.exit(1)
def setUp(self):
"""Test initialization."""
valid_xml_name = Path(__file__).parents[0].joinpath(
'valid_SDLRPCV2.xml').as_posix()
self.interface = Parser().parse(valid_xml_name)
self.assertIsNotNone(self.interface)