Merge pull request #2 from dxworks/victorc/update-kt

Victorc/update kt

Author: MarioRivis

README.rst

@@ -34,6 +34,7 @@ A list of supported languages:
 -  Lua
 -  Rust
 -  Fortran
+-  Kotlin
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use

lizard.py

@@ -563,10 +563,13 @@ def analyze_source_code(self, filename, code):
         context = FileInfoBuilder(filename)
         reader = (get_reader_for(filename) or CLikeReader)(context)
         tokens = reader.generate_tokens(code)
-        for processor in self.processors:
-            tokens = processor(tokens, reader)
-        for _ in reader(tokens, reader):
-            pass
+        try:
+            for processor in self.processors:
+                tokens = processor(tokens, reader)
+            for _ in reader(tokens, reader):
+                pass
+        except RecursionError as e:
+            sys.stderr.write("[skip] fail to process '%s' with RecursionError - %s\n" % (filename, e))
         return context.fileinfo
 
 

lizard_languages/__init__.py

@@ -3,6 +3,7 @@
 from .clike import CLikeReader
 from .java import JavaReader
 from .javascript import JavaScriptReader
+from .kotlin import KotlinReader
 from .python import PythonReader
 from .objc import ObjCReader
 from .ttcn import TTCNReader
@@ -37,7 +38,8 @@ def languages():
         LuaReader,
         RustReader,
         TypeScriptReader,
-        FortranReader
+        FortranReader,
+        KotlinReader
     ]
 
 

lizard_languages/kotlin.py

@@ -0,0 +1,92 @@
+'''
+Language parser for Apple Swift
+'''
+
+from .clike import CCppCommentsMixin
+from .code_reader import CodeReader, CodeStateMachine
+from .golike import GoLikeStates
+from .swift import SwiftReplaceLabel
+
+
+class KotlinReader(CodeReader, CCppCommentsMixin, SwiftReplaceLabel):
+    # pylint: disable=R0903
+
+    ext = ['kt', 'kts']
+    language_names = ['kotlin']
+    _conditions = {
+        'if', 'for', 'while', 'catch', '&&', '||', '?:'
+    }
+
+    def __init__(self, context):
+        super(KotlinReader, self).__init__(context)
+        self.parallel_states = [KotlinStates(context)]
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        return CodeReader.generate_tokens(
+            source_code,
+            r"|`\w+`" +
+            r"|\w+\?" +
+            r"|\w+\!!" +
+            r"|\?\?" +
+            r"|\?:" +
+            addition
+        )
+
+
+class KotlinStates(GoLikeStates):  # pylint: disable=R0903
+
+    FUNC_KEYWORD = 'fun'
+
+    def __init__(self, context, in_when_cases=False):
+        super().__init__(context)
+        self._in_when_cases = in_when_cases
+
+    def _state_global(self, token):
+        if token in ('get', 'set'):
+            self.context.push_new_function(token)
+            self._state = self._expect_function_impl
+        elif token == '->':
+            if self._in_when_cases:
+                self.context.add_condition()
+            else:
+                self.context.push_new_function("(anonymous)")
+                self._state = super(KotlinStates, self)._expect_function_impl
+        elif token in ('val', 'var', ','):
+            self._state = self._expect_declaration_name
+        elif token == 'interface':
+            self._state = self._interface
+        elif token == 'when':
+            self._state = self._when_cases
+        else:
+            super(KotlinStates, self)._state_global(token)
+
+    def _expect_declaration_name(self, token):
+        self._state = self._state_global
+
+    def _expect_function_impl(self, token):
+        if token == '{' or token == '=':
+            self.next(self._function_impl, token)
+
+    @CodeStateMachine.read_inside_brackets_then("{}")
+    def _interface(self, end_token):
+        if end_token == "}":
+            self._state = self._state_global
+
+    def _function_name(self, token):
+        if token == "<":
+            self.next(self._template, token)
+        else:
+            return super(KotlinStates, self)._function_name(token)
+
+    @CodeStateMachine.read_inside_brackets_then("<>", "_function_name")
+    def _template(self, tokens):
+        pass
+
+    def _when_cases(self, token):
+        def callback():
+            self.context.add_condition(inc=-1)
+            self.next(self._state_global)
+        if token != '{':
+            return
+        self.sub_state(KotlinStates(self.context, in_when_cases=True), callback)

lizard_languages/swift.py

@@ -7,7 +7,24 @@
 from .golike import GoLikeStates
 
 
-class SwiftReader(CodeReader, CCppCommentsMixin):
+class SwiftReplaceLabel:
+    def preprocess(self, tokens):
+        tokens = list(t for t in tokens if not t.isspace() or t == '\n')
+
+        def replace_label(tokens, target, replace):
+            for i in range(0, len(tokens) - len(target)):
+                if tokens[i:i + len(target)] == target:
+                    for j, repl in enumerate(replace):
+                        tokens[i + j] = repl
+            return tokens
+
+        for k in (k for k in self.conditions if k.isalpha()):
+            tokens = replace_label(tokens, ["(", k, ":"], ["(", "_" + k, ":"])
+            tokens = replace_label(tokens, [",", k, ":"], [",", "_" + k, ":"])
+        return tokens
+
+
+class SwiftReader(CodeReader, CCppCommentsMixin, SwiftReplaceLabel):
     # pylint: disable=R0903
 
     FUNC_KEYWORD = 'def'
@@ -30,20 +47,6 @@ def generate_tokens(source_code, addition='', token_class=None):
             r"|\?\?" +
             addition)
 
-    def preprocess(self, tokens):
-        tokens = list(t for t in tokens if not t.isspace() or t == '\n')
-
-        def replace_label(tokens, target, replace):
-            for i in range(0, len(tokens) - len(target)):
-                if tokens[i:i + len(target)] == target:
-                    for j, repl in enumerate(replace):
-                        tokens[i + j] = repl
-            return tokens
-        for k in (k for k in self.conditions if k.isalpha()):
-            tokens = replace_label(tokens, ["(", k, ":"], ["(", "_" + k, ":"])
-            tokens = replace_label(tokens, [",", k, ":"], [",", "_" + k, ":"])
-        return tokens
-
 
 class SwiftStates(GoLikeStates):  # pylint: disable=R0903
     def _state_global(self, token):