Merge branch 'SDL-0234-keywords' into SDL-0234-Proxy-Library-RPC-Generation

# Conflicts:
#	generator/rpc_spec

Author: Kostiantyn Sologubov

generator/generator.py

@@ -242,40 +242,66 @@ def versions_compatibility_validating(self):
         self.logger.info('Parser type: %s, version %s,\tGenerator version %s',
                          basename(getfile(Parser().__class__)), parser_origin, self.get_version)
 
+    def get_file_content(self, file_name: Path) -> list:
+        """
+
+        :param file_name:
+        :return:
+        """
+        try:
+            with file_name.open('r') as file:
+                content = file.readlines()
+            return content
+        except FileNotFoundError as message1:
+            self.logger.error(message1)
+            return []
+
+    def get_key_words(self, file_name=ROOT.joinpath('rpc_spec/RpcParser/RESERVED_KEYWORDS')):
+        """
+        :param file_name:
+        :return:
+        """
+        content = self.get_file_content(file_name)
+        content = tuple(map(lambda e: re.sub(r'\n', r'', e).strip().casefold(), content))
+        try:
+            content = tuple(filter(lambda e: not re.search(r'^#+\s+.+|^$', e), content))
+            self.logger.debug('key_words: %s', ', '.join(content))
+            return content
+        except (IndexError, ValueError, StopIteration) as error1:
+            self.logger.error('Error while getting key_words, %s %s', type(error1).__name__, error1)
+            return []
+
     def get_paths(self, file_name=ROOT.joinpath('paths.ini')):
         """
         :param file_name: path to file with Paths
         :return: namedtuple with Paths to key elements
         """
         fields = ('struct_class', 'request_class', 'response_class',
                   'notification_class', 'enums_package', 'structs_package', 'functions_package')
-        intermediate = OrderedDict()
-        try:
-            with file_name.open('r') as file:
-                for line in file:
-                    if line.startswith('#'):
-                        self.logger.warning('commented property %s, which will be skipped', line.strip())
-                        continue
-                    if re.match(r'^(\w+)\s?=\s?(.+)', line):
-                        if len(line.split('=')) > 2:
-                            self.logger.critical('can not evaluate value, too many separators %s', str(line))
-                            sys.exit(1)
-                        name, var = line.partition('=')[::2]
-                        if name.strip() in intermediate:
-                            self.logger.critical('duplicate key %s', name)
-                            sys.exit(1)
-                        intermediate[name.strip().lower()] = var.strip()
-        except FileNotFoundError as message1:
-            self.logger.critical(message1)
-            sys.exit(1)
+        data = OrderedDict()
+        content = self.get_file_content(file_name)
+
+        for line in content:
+            if line.startswith('#'):
+                self.logger.warning('commented property %s, which will be skipped', line.strip())
+                continue
+            if re.match(r'^(\w+)\s?=\s?(.+)', line):
+                if len(line.split('=')) > 2:
+                    self.logger.critical('can not evaluate value, too many separators %s', str(line))
+                    sys.exit(1)
+                name, var = line.partition('=')[::2]
+                if name.strip() in data:
+                    self.logger.critical('duplicate key %s', name)
+                    sys.exit(1)
+                data[name.strip().lower()] = var.strip()
 
         for line in fields:
-            if line not in intermediate:
-                self.logger.critical('in %s missed fields: %s ', file, str(line))
+            if line not in data:
+                self.logger.critical('in %s missed fields: %s ', content, str(line))
                 sys.exit(1)
 
         Paths = namedtuple('Paths', ' '.join(fields))
-        return Paths(**intermediate)
+        return Paths(**data)
 
     def write_file(self, file_name, template, data):
         """
@@ -399,16 +425,17 @@ def main(self):
                                                           pattern=args.regex_pattern)
 
         paths = self.get_paths()
+        key_words = self.get_key_words()
 
         if args.enums and interface.enums:
             self.process(args.output_directory, args.skip, args.overwrite, tuple(interface.enums.values()),
-                         EnumsProducer(paths))
+                         EnumsProducer(paths, key_words))
         if args.structs and interface.structs:
             self.process(args.output_directory, args.skip, args.overwrite, tuple(interface.structs.values()),
-                         StructsProducer(paths, enum_names, struct_names))
+                         StructsProducer(paths, enum_names, struct_names, key_words))
         if args.functions and interface.functions:
             self.process(args.output_directory, args.skip, args.overwrite, tuple(interface.functions.values()),
-                         FunctionsProducer(paths, enum_names, struct_names))
+                         FunctionsProducer(paths, enum_names, struct_names, key_words))
 
 
 if __name__ == '__main__':

generator/test/test_enums.py

@@ -4,14 +4,16 @@
 from model.enum import Enum
 from model.enum_element import EnumElement
 from transformers.enums_producer import EnumsProducer
+from generator import Generator
 
 
 class TestEnumsProducer(unittest.TestCase):
     def setUp(self):
         self.maxDiff = None
         Paths = namedtuple('Prop', 'enums_package')
         paths = Paths(enums_package='com.smartdevicelink.proxy.rpc.enums')
-        self.producer = EnumsProducer(paths)
+        keywords = Generator().get_key_words()
+        self.producer = EnumsProducer(paths, keywords)
 
     def comparison(self, expected, actual):
         actual = OrderedDict(sorted(actual.items()))

generator/test/test_functions.py

@@ -13,6 +13,7 @@
 from model.string import String
 from model.struct import Struct
 from transformers.functions_producer import FunctionsProducer
+from generator import Generator
 
 
 class TestFunctionsProducer(unittest.TestCase):
@@ -33,7 +34,8 @@ def setUp(self):
         self.expected_template['deprecated'] = None
         enum_names = ('FileType', 'Language')
         struct_names = ('SdlMsgVersion', 'TemplateColorScheme', 'TTSChunk', 'Choice')
-        self.producer = FunctionsProducer(paths, enum_names, struct_names)
+        keywords = Generator().get_key_words()
+        self.producer = FunctionsProducer(paths, enum_names, struct_names, keywords)
 
     def comparison(self, expected, actual):
         actual_params = dict(zip(map(lambda k: k.title, actual['params']), actual['params']))

generator/test/test_structs.py

@@ -8,6 +8,7 @@
 from model.string import String
 from model.struct import Struct
 from transformers.structs_producer import StructsProducer
+from generator import Generator
 
 
 class TestStructsProducer(unittest.TestCase):
@@ -17,7 +18,8 @@ def setUp(self):
         paths = Paths(enums_package='com.smartdevicelink.proxy.rpc.enums',
                       structs_package='com.smartdevicelink.proxy.rpc',
                       struct_class='com.smartdevicelink.proxy.RPCStruct')
-        self.producer = StructsProducer(paths, ['SamplingRate'], ('Image',))
+        keywords = Generator().get_key_words()
+        self.producer = StructsProducer(paths, ['SamplingRate'], ('Image',), keywords)
 
     def comparison(self, expected, actual):
         actual_params = dict(zip(map(lambda k: k.origin, actual['params']), actual['params']))

generator/transformers/common_producer.py

@@ -20,11 +20,12 @@ class InterfaceProducerCommon(ABC):
     version = '1.0.0'
 
     def __init__(self, container_name, enums_package, structs_package, package_name,
-                 enum_names=(), struct_names=()):
+                 enum_names=(), struct_names=(), key_words=()):
         self.logger = logging.getLogger('Generator.InterfaceProducerCommon')
         self.container_name = container_name
         self.enum_names = enum_names
         self.struct_names = struct_names
+        self.key_words = key_words
         self.enums_package = enums_package
         self.structs_package = structs_package
         self.package_name = package_name
@@ -85,6 +86,20 @@ def replace_sync(name):
             return re.sub(r'^([sS])ync(.+)$', r'\1dl\2', name)
         return name
 
+    def replace_keywords(self, name: str = '') -> str:
+        """
+        if :param name in self.key_words, :return: name += 'Param'
+        :param name: string with item name
+        """
+        if any(map(lambda k: re.search(r'^(get|set|key_)?{}$'.format(name.casefold()), k), self.key_words)):
+            origin = name
+            if name.isupper():
+                name += '_PARAM'
+            else:
+                name += 'Param'
+            self.logger.debug('Replacing %s with %s', origin, name)
+        return self.replace_sync(name)
+
     def extract_type(self, param):
         """
         Evaluate and extract type

generator/transformers/enums_producer.py

@@ -16,12 +16,13 @@ class EnumsProducer(InterfaceProducerCommon):
     Enums transformation
     """
 
-    def __init__(self, paths):
+    def __init__(self, paths, key_words):
         super(EnumsProducer, self).__init__(
             container_name='elements',
             enums_package=None,
             structs_package=None,
-            package_name=paths.enums_package)
+            package_name=paths.enums_package,
+            key_words=key_words)
         self.logger = logging.getLogger('EnumsProducer')
         self._params = namedtuple('params', 'origin name internal description since value deprecated')
 

generator/transformers/functions_producer.py

@@ -16,14 +16,15 @@ class FunctionsProducer(InterfaceProducerCommon):
     Functions transformation
     """
 
-    def __init__(self, paths, enum_names, struct_names):
+    def __init__(self, paths, enum_names, struct_names, key_words):
         super(FunctionsProducer, self).__init__(
             container_name='params',
             enums_package=paths.enums_package,
             structs_package=paths.structs_package,
             enum_names=enum_names,
             struct_names=struct_names,
-            package_name=paths.functions_package)
+            package_name=paths.functions_package,
+            key_words=key_words)
         self.logger = logging.getLogger('FunctionsProducer')
         self.request_class = paths.request_class
         self.response_class = paths.response_class
@@ -36,7 +37,7 @@ def transform(self, item: Function) -> dict:
         :param item: particular element from initial Model
         :return: dictionary to be applied to jinja2 template
         """
-        class_name = self.replace_sync(item.name[:1].upper() + item.name[1:])
+        class_name = self.replace_keywords(item.name[:1].upper() + item.name[1:])
 
         imports = {'java.util.Hashtable', 'com.smartdevicelink.protocol.enums.FunctionID'}
         extends_class = None
@@ -58,7 +59,7 @@ def transform(self, item: Function) -> dict:
 
         for param in getattr(item, self.container_name).values():
             param.origin = param.name
-            param.name = self.replace_sync(param.name)
+            param.name = self.replace_keywords(param.name)
             i, p = self.extract_param(param)
             imports.update(i)
             params.update({param.name: p})
@@ -67,7 +68,7 @@ def transform(self, item: Function) -> dict:
         render['kind'] = item.message_type.name
         render['package_name'] = self.package_name
         render['imports'] = self.sort_imports(imports)
-        render['function_id'] = self.key(self.replace_sync(item.name))
+        render['function_id'] = self.key(self.replace_keywords(item.name))
         render['class_name'] = class_name
         render['extends_class'] = extends_class
         render['since'] = item.since

generator/transformers/structs_producer.py

@@ -16,14 +16,15 @@ class StructsProducer(InterfaceProducerCommon):
     Structs transformation
     """
 
-    def __init__(self, paths, enum_names, struct_names):
+    def __init__(self, paths, enum_names, struct_names, key_words):
         super(StructsProducer, self).__init__(
             container_name='members',
             enums_package=paths.enums_package,
             structs_package=paths.structs_package,
             enum_names=enum_names,
             struct_names=struct_names,
-            package_name=paths.structs_package)
+            package_name=paths.structs_package,
+            key_words=key_words)
         self.logger = logging.getLogger('StructsProducer')
         self.struct_class = paths.struct_class
 
@@ -33,7 +34,7 @@ def transform(self, item: Struct) -> dict:
         :param item: particular element from initial Model
         :return: dictionary to be applied to jinja2 template
         """
-        class_name = self.replace_sync(item.name[:1].upper() + item.name[1:])
+        class_name = self.replace_keywords(item.name[:1].upper() + item.name[1:])
 
         imports = {'java.util.Hashtable'}
         extends_class = self.struct_class
@@ -44,7 +45,7 @@ def transform(self, item: Struct) -> dict:
         params = OrderedDict()
 
         for param in getattr(item, self.container_name).values():
-            param.name = self.replace_sync(param.name)
+            param.name = self.replace_keywords(param.name)
             i, p = self.extract_param(param)
             imports.update(i)
             params[param.name] = p