echanced deprecated view

8 files changed, 90 insertions, 59 deletions

diff --git a/generator/templates/base_struct_function.m b/generator/templates/base_struct_function.m
index 4c991b1ad..8e98fddd4 100644
--- a/generator/templates/base_struct_function.m
+++ b/generator/templates/base_struct_function.m
@@ -12,7 +12,7 @@
 NS_ASSUME_NONNULL_BEGIN
 {% if deprecated %}
 #pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma clang diagnostic ignored "-Wdeprecated-implementations"
 {%- endif %}
 @implementation {{name}}
 {%- if deprecated %}
@@ -25,9 +25,6 @@ NS_ASSUME_NONNULL_BEGIN
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
 - (instancetype)initWith{{c.init}} {
-{%- if deprecated or c.deprecated %}
-#pragma clang diagnostic pop
-{%- endif %}
     self = [{{ 'self' if c.self else 'super' }} init{{ 'With' + c.self if c.self and c.self is string }}];
     if (!self) {
         return nil;
@@ -37,32 +34,35 @@ NS_ASSUME_NONNULL_BEGIN
     {%- endfor %}
     return self;
 }
+{%- if deprecated or c.deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
 {% endfor -%}
 {% endblock -%}
 {%- block methods %}
-{%- for p in params %}
-{%- if deprecated or p.deprecated %}
+{%- for param in params %}
+{%- if deprecated or param.deprecated %}
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
-- (void)set{{p.origin|title}}:({{'nullable ' if not p.mandatory}}{{p.type_generic}}{{p.type_sdl|trim}}){{p.origin}} {
-{%- if deprecated or p.deprecated %}
+- (void)set{{param.origin|title}}:({{'nullable ' if not param.mandatory}}{{param.type_generic}}{{param.type_sdl|trim}}){{param.origin}} {
+{%- if deprecated or param.deprecated %}
 #pragma clang diagnostic pop
 {%- endif %}
-    [self.{{parameters_store}} sdl_setObject:{{p.origin}} forName:SDLRPCParameterName{{p.method_suffix}}];
+    [self.{{parameters_store}} sdl_setObject:{{param.origin}} forName:SDLRPCParameterName{{param.method_suffix}}];
 }
-{% if deprecated or p.deprecated %}
+{% if deprecated or param.deprecated %}
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
-- ({{'nullable ' if not p.mandatory}}{{p.type_generic}}{{p.type_sdl|trim}}){{p.origin}} {
-{%- if deprecated or p.deprecated %}
+- ({{'nullable ' if not param.mandatory}}{{param.type_generic}}{{param.type_sdl|trim}}){{param.origin}} {
+{%- if deprecated or param.deprecated %}
 #pragma clang diagnostic pop
 {%- endif %}
-    {% if p.mandatory -%}
+    {% if param.mandatory -%}
     NSError *error = nil;
     {% endif -%}
-    return [self.{{parameters_store}} sdl_{{p.for_name}}ForName:SDLRPCParameterName{{p.method_suffix}}{{' ofClass:'+p.of_class if p.of_class}} error:{{'&error' if p.mandatory else 'nil'}}];
+    return [self.{{parameters_store}} sdl_{{param.for_name}}ForName:SDLRPCParameterName{{param.method_suffix}}{{' ofClass:'+param.of_class if param.of_class}} error:{{'&error' if param.mandatory else 'nil'}}];
 }
 {% endfor %}
 {%- endblock %}
diff --git a/generator/templates/enums/template.h b/generator/templates/enums/template.h
index a0dea105a..e3d6927dc 100644
--- a/generator/templates/enums/template.h
+++ b/generator/templates/enums/template.h
@@ -8,15 +8,21 @@
 {%- block body %}
 {% include 'description.jinja' %}
 typedef SDLEnum {{ name }} SDL_SWIFT_ENUM{{ending}};
-{% for param in params %}
-{%- include 'description_param.jinja' %}
-{% if deprecated or param.deprecated -%}
+{% if deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{% endif %}
+{%- for param in params %}
+{%- include 'description_param.jinja' %}{% if param.deprecated %}
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
 {%- endif %}
 extern {{ name }} const {{ name }}{{param.name}}{{ " __deprecated" if param.deprecated and param.deprecated }};
-{% if deprecated or param.deprecated -%}
+{% if param.deprecated -%}
 #pragma clang diagnostic pop
-{%- endif %}
+{%- endif -%}
 {% endfor -%}
+{%- if deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
 {% endblock -%}
diff --git a/generator/templates/enums/template.m b/generator/templates/enums/template.m
index 5a83cb680..dc13f4611 100644
--- a/generator/templates/enums/template.m
+++ b/generator/templates/enums/template.m
@@ -5,7 +5,21 @@
 {% if add_typedef %}
 typedef SDLEnum {{name}} SDL_SWIFT_ENUM;
 {% endif -%}
+{%- if deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 {%- for param in params %}
+{%- if param.deprecated %}
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+{%- endif %}
 {{ name }} const {{ name }}{{param.name}} = @"{{param.origin}}";
-{%- endfor %}
+{%- if param.deprecated %}
+#pragma clang diagnostic pop
+{% endif %}
+{%- endfor -%}
+{%- if deprecated %}
+#pragma clang diagnostic pop
+{%- endif %}
 {% endblock -%}
diff --git a/generator/test/test_enums.py b/generator/test/test_enums.py
index b3a5a7f42..d7e14786a 100644
--- a/generator/test/test_enums.py
+++ b/generator/test/test_enums.py
@@ -45,11 +45,11 @@ class TestEnumsProducer(TestCase):
         expected['name'] = 'SDLFunctionID'
         expected['imports'] = {'.h': {'SDLEnum'}, '.m': {'SDLEnum'}}
         expected['params'] = (
-            self.producer.param_named(description=[], name='Reserved', origin='RESERVED', since=None),
+            self.producer.param_named(description=[], name='Reserved', origin='RESERVED', since=None, deprecated=False),
             self.producer.param_named(description=[], name='RegisterAppInterface', origin='RegisterAppInterfaceID',
-                                      since=None),
+                                      since=None, deprecated=False),
             self.producer.param_named(description=[], name='PerformAudioPassThru', origin='PerformAudioPassThruID',
-                                      since=None),)
+                                      since=None, deprecated=False),)
 
         actual = self.producer.transform(item)
         self.assertDictEqual(expected, actual)
@@ -71,11 +71,13 @@ class TestEnumsProducer(TestCase):
         expected['name'] = 'SDLTextFieldName'
         expected['imports'] = {'.h': {'SDLEnum'}, '.m': {'SDLEnum'}}
         expected['params'] = (
-            self.producer.param_named(description=[], name='SuccessParam', origin='SUCCESS_PARAM', since=None),
-            self.producer.param_named(description=[], name='MainField1', origin='mainField1', since=None),
-            self.producer.param_named(description=[], name='H264', origin='H264', since=None),
+            self.producer.param_named(description=[], name='SuccessParam', origin='SUCCESS', since=None,
+                                      deprecated=False),
+            self.producer.param_named(description=[], name='MainField1', origin='mainField1', since=None,
+                                      deprecated=False),
+            self.producer.param_named(description=[], name='H264', origin='H264', since=None, deprecated=False),
             self.producer.param_named(description=[], name='UnsupportedRequest', origin='UNSUPPORTED_REQUEST',
-                                      since=None))
+                                      since=None, deprecated=False))
 
         actual = self.producer.transform(item)
         self.assertDictEqual(expected, actual)
diff --git a/generator/transformers/common_producer.py b/generator/transformers/common_producer.py
index d1550c8c2..987ed5934 100644
--- a/generator/transformers/common_producer.py
+++ b/generator/transformers/common_producer.py
@@ -26,7 +26,7 @@ class InterfaceProducerCommon(ABC):
 
     def __init__(self, enum_names=(), struct_names=(), key_words=()):
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.struct_names = tuple(map(lambda e: self.replace_sync(e), struct_names))
+        self.struct_names = tuple(map(lambda e: self._replace_sync(e), struct_names))
         self.key_words = key_words
         self.param_named = namedtuple('param_named',
                                       'origin constructor_argument constructor_prefix deprecated mandatory since '
@@ -34,7 +34,7 @@ class InterfaceProducerCommon(ABC):
                                       'constructor_argument_override')
         self.constructor_named = namedtuple('constructor', 'init self arguments all deprecated')
         self.argument_named = namedtuple('argument', 'origin constructor_argument variable deprecated')
-        self.names = self.struct_names + tuple(map(lambda e: self.replace_sync(e), enum_names))
+        self.names = self.struct_names + tuple(map(lambda e: self._replace_sync(e), enum_names))
 
     @property
     @abstractmethod
@@ -61,10 +61,7 @@ class InterfaceProducerCommon(ABC):
         render['params'] = OrderedDict()
 
         for param in getattr(item, self.container_name).values():
-            # if param.name.lower() == 'id':
-            #     param.name = self.minimize_first(item.name) + self.title(param.name)
-            param.name = self.replace_keywords(param.name)
-            render['params'][param.name] = self.extract_param(param)
+            render['params'][param.name] = self.extract_param(param, item.name)
             if isinstance(item, (Struct, Function)):
                 self.extract_imports(param, render['imports'])
 
@@ -74,22 +71,26 @@ class InterfaceProducerCommon(ABC):
         render['params'] = tuple(render['params'].values())
         return render
 
-    def replace_keywords(self, name: str = '') -> str:
+    def _replace_keywords(self, name: str) -> str:
+        origin = name
+        if name.isupper():
+            name += '_PARAM'
+        else:
+            name += 'Param'
+        self.logger.debug('Replacing %s with %s', origin, 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 name.casefold() in 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)
+            name = self._replace_keywords(name)
+        return self._replace_sync(name)
 
     @staticmethod
-    def replace_sync(name):
+    def _replace_sync(name):
         """
         :param name: string with item name
         :return: string with replaced 'sync' to 'Sdl'
@@ -124,7 +125,7 @@ class InterfaceProducerCommon(ABC):
         :return: tuple with element.name, type(element).__name__.lower()
         """
         if isinstance(element, (Struct, Enum)):
-            return self.replace_sync(element.name), type(element).__name__.lower()
+            return self._replace_sync(element.name), type(element).__name__.lower()
         return None, None
 
     @staticmethod
@@ -324,12 +325,13 @@ class InterfaceProducerCommon(ABC):
                 'constructor_prefix': InterfaceProducerCommon.title(name),
                 'method_suffix': InterfaceProducerCommon.title(name)}
 
-    def extract_param(self, param: Param):
+    def extract_param(self, param: Param, item_name: str):
         """
         Preparing self.param_named with prepared params
         :param param: Param from initial Model
         :return: self.param_named with prepared params
         """
+        param.name = self.replace_keywords(param.name)
         data = {'constructor_argument_override': None,
                 'description': self.extract_description(param.description),
                 'since': param.since,
diff --git a/generator/transformers/enums_producer.py b/generator/transformers/enums_producer.py
index cd44a640d..69797f772 100644
--- a/generator/transformers/enums_producer.py
+++ b/generator/transformers/enums_producer.py
@@ -1,6 +1,7 @@
 """
 Enums transformer
 """
+import json
 import logging
 import re
 from collections import namedtuple, OrderedDict
@@ -20,7 +21,8 @@ class EnumsProducer(InterfaceProducerCommon):
         self._container_name = 'elements'
         self.enum_class = enum_class
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.param_named = namedtuple('param_named', 'origin description name since')
+        self.param_named = namedtuple('param_named', 'origin description name since deprecated')
+        self._item_name = None
 
     @property
     def container_name(self):
@@ -34,7 +36,7 @@ class EnumsProducer(InterfaceProducerCommon):
         :param render: empty dictionary, present in parameter for code consistency
         :return: dictionary which going to be applied to Jinja2 template
         """
-        item.name = self.replace_sync(item.name)
+        item.name = self._replace_sync(item.name)
         name = 'SDL{}{}'.format(item.name[:1].upper(), item.name[1:])
         tmp = {self.enum_class}
         imports = {'.h': tmp, '.m': tmp}
@@ -46,29 +48,34 @@ class EnumsProducer(InterfaceProducerCommon):
         super(EnumsProducer, self).transform(item, render)
         return render
 
-    def extract_param(self, param: EnumElement):
+    def extract_param(self, param: EnumElement, item_name: str):
         """
         Preparing self.param_named with prepared params
         :param param: EnumElement from initial Model
+        :param item_name:
         :return: self.param_named with prepared params
         """
-        data = {'origin': param.name, 'description': self.extract_description(param.description, 113),
-                'since': param.since}
-
+        data = {'origin': param.name,
+                'description': self.extract_description(param.description),
+                'since': param.since,
+                'deprecated': json.loads(param.deprecated.lower()) if param.deprecated else False}
+        name = None
         if re.match(r'^[A-Z]{1,2}\d|\d[A-Z]{1,2}$', param.name):
-            data['name'] = param.name
+            name = param.name
         elif re.match(r'(^[a-z\d]+$|^[A-Z\d]+$)', param.name):
-            data['name'] = param.name.title()
+            name = param.name.title()
         elif re.match(r'^(?=\w*[a-z])(?=\w*[A-Z])\w+$', param.name):
             if param.name.endswith('ID'):
-                data['name'] = param.name[:-2]
+                name = param.name[:-2]
             else:
-                data['name'] = param.name[:1].upper() + param.name[1:]
+                name = param.name[:1].upper() + param.name[1:]
         elif re.match(r'^(?=\w*?[a-zA-Z])(?=\w*?[_-])(?=[0-9])?.*$', param.name):
             name = []
             for item in re.split('[_-]', param.name):
                 if re.match(r'^[A-Z\d]+$', item):
                     name.append(item.title())
-            data['name'] = ''.join(name)
-
+            name = ''.join(name)
+        if any(re.search(r'^(sdl)?({})?{}$'.format(item_name.casefold(), name.casefold()), k) for k in self.key_words):
+            name = self._replace_keywords(name)
+        data['name'] = name
         return self.param_named(**data)
diff --git a/generator/transformers/functions_producer.py b/generator/transformers/functions_producer.py
index f858a8267..fcab84a14 100644
--- a/generator/transformers/functions_producer.py
+++ b/generator/transformers/functions_producer.py
@@ -38,7 +38,7 @@ class FunctionsProducer(InterfaceProducerCommon):
         :return: dictionary which going to be applied to Jinja2 template
         """
         list(map(item.params.__delitem__, filter(item.params.__contains__, ['success', 'resultCode', 'info'])))
-        item.name = self.replace_sync(item.name)
+        item.name = self._replace_sync(item.name)
         name = 'SDL' + item.name
         imports = {'.h': {'enum': set(), 'struct': set()}, '.m': set()}
         extends_class = None
@@ -86,7 +86,7 @@ class FunctionsProducer(InterfaceProducerCommon):
         :return: dictionary with evaluated part of output collection
         """
         origin = element.name
-        name = self.replace_sync(element.name)
+        name = self._replace_sync(element.name)
         # if isinstance(element.param_type, (Integer, Float, Boolean, String)):
         return {name: self.common_names(**{
             'name': self.title(name),
diff --git a/generator/transformers/structs_producer.py b/generator/transformers/structs_producer.py
index 2c9e0ec64..b25d86230 100644
--- a/generator/transformers/structs_producer.py
+++ b/generator/transformers/structs_producer.py
@@ -32,7 +32,7 @@ class StructsProducer(InterfaceProducerCommon):
         :param render: dictionary with pre filled entries, which going to be filled/changed by reference
         :return: dictionary which going to be applied to Jinja2 template
         """
-        item.name = self.replace_sync(item.name)
+        item.name = self._replace_sync(item.name)
         name = 'SDL' + item.name
         imports = {'.h': {'enum': set(), 'struct': set()}, '.m': set()}
         imports['.h']['enum'].add(self.struct_class)