Refactoring of conventions code

* Simplifies convention classes, moves all special names
processing code into specs.
 * Now it is possible to have special functions with suffixes
 that conventions will apply to. For example
 #prefix_name_do_something will remain intact but
 #prefix_name#do_something will be converted to
 #prefix_name#doSomething. This will be later used to implement
properties

Change-Id: I3b0c7bc71cbf97015a70f447b192d69c5e53f14b

yaql/language/conventions.py

@@ -12,28 +12,28 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import abc
 import re
 
+import six
 
+
+@six.add_metaclass(abc.ABCMeta)
 class Convention(object):
+    @abc.abstractmethod
     def convert_function_name(self, name):
-        return name
+        pass
 
+    @abc.abstractmethod
     def convert_parameter_name(self, name):
-        return name
+        pass
 
 
 class PythonConvention(Convention):
     def convert_function_name(self, name):
-        if not name or not name[0].isalpha():
-            return name
-
         return name
 
     def convert_parameter_name(self, name):
-        if not name or not name[0].isalpha():
-            return name
-
         return name
 
 
@@ -42,14 +42,9 @@ class CamelCaseConvention(Convention):
         self.regex = re.compile(r'(?!^)_(\w)', flags=re.UNICODE)
 
     def convert_function_name(self, name):
-        if not name or not name[0].isalpha():
-            return name
-
         return self._to_camel_case(name)
 
     def convert_parameter_name(self, name):
-        if not name or not name[0].isalpha():
-            return name
         return self._to_camel_case(name)
 
     def _to_camel_case(self, name):

yaql/language/specs.py

@@ -371,6 +371,30 @@ def _infer_parameter_type(name):
         return yaqltypes.Engine()
 
 
+def convert_function_name(function_name, convention):
+    if not function_name:
+        return function_name
+    function_name = function_name.rstrip('_')
+    if not convention:
+        return function_name
+    if not function_name[0].isalpha():
+        finish = function_name.find(function_name[0], 1)
+        if finish <= 1:
+            return function_name
+        return function_name[:finish + 1] + convention.convert_function_name(
+            function_name[finish + 1:])
+    return convention.convert_function_name(function_name)
+
+
+def convert_parameter_name(parameter_name, convention):
+    if not parameter_name:
+        return parameter_name
+    parameter_name = parameter_name.rstrip('_')
+    if not convention:
+        return parameter_name
+    return convention.convert_parameter_name(parameter_name)
+
+
 def get_function_definition(func, name=None, function=None, method=None,
                             convention=None, parameter_type_func=None):
     if parameter_type_func is None:
@@ -398,13 +422,9 @@ def get_function_definition(func, name=None, function=None, method=None,
     if name is not None:
         fd.name = name
     elif fd.name is None:
-        if convention is not None:
-            fd.name = convention.convert_function_name(
-                fd.payload.__name__.rstrip('_'))
-        else:
-            fd.name = fd.payload.__name__.rstrip('_')
+        fd.name = convert_function_name(fd.payload.__name__, convention)
     elif convention is not None:
-        fd.name = convention.convert_function_name(fd.name.rstrip('_'))
+        fd.name = convert_function_name(fd.name, convention)
 
     if function is not None:
         fd.is_function = function
@@ -413,8 +433,7 @@ def get_function_definition(func, name=None, function=None, method=None,
     if convention:
         for p in six.itervalues(fd.parameters):
             if p.alias is None:
-                p.alias = convention.convert_parameter_name(p.name.rstrip('_'))
-
+                p.alias = convert_parameter_name(p.name, convention)
     return fd