lizard 1.17.9__py2.py3-none-any.whl → 1.17.12__py2.py3-none-any.whl

{lizard-1.17.9.dist-info → lizard-1.17.12.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.9
+Version: 1.17.12
 Summary: A code analyzer without caring the C/C++ header files. It works with Java, C/C++, JavaScript, Python, Ruby, Swift, Objective C. Metrics includes cyclomatic complexity number etc.
 Home-page: http://www.lizard.ws
+Download-URL: https://pypi.python.org/lizard/
 Author: Terry Yin
 Author-email: terry@odd-e.com
 License: MIT
-Download-URL: https://pypi.python.org/lizard/
+Project-URL: Source, https://github.com/terryyin/lizard
 Platform: any
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -22,10 +23,11 @@ Classifier: Programming Language :: Java
 Classifier: Programming Language :: JavaScript
 Classifier: Programming Language :: Objective C
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+License-File: LICENSE.txt
 
 |Web Site| Lizard
 =================
@@ -63,6 +65,9 @@ A list of supported languages:
 -  Lua
 -  Rust
 -  Fortran
+-  Kotlin
+-  Solidity
+-  Erlang
 
 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
@@ -85,7 +90,7 @@ often very hard to get all the included folders and files right when
 they are complicated. But we don't really need that kind of accuracy for
 cyclomatic complexity.
 
-It requires python2.7 or above (early versions are not verified).
+It requires python3.8 or above (early versions are not verified).
 
 Installation
 ------------
@@ -109,7 +114,7 @@ Or if you've got the source:
 
 ::
 
-   [sudo] python setup.py install --install-dir=/path/to/installation/directory/
+   [sudo] python setup.py install --prefix=/path/to/installation/directory/
 
 Usage
 -----

{lizard-1.17.9.dist-info → lizard-1.17.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lizard.py,sha256=B-IJWqsIEmR_dHugY_i85-MtAdLJCRPsRWjvkfjI1a0,38150
+lizard.py,sha256=KR3F6F-5GzGQP0GLxjWmpRRUsLbfL-Lthtz3jWLlyPY,38576
 lizard_ext/__init__.py,sha256=Cz0pvH6QHyadK-rAeeEhQVsm0hW5M-fBQgV4FBaX9zk,500
 lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
 lizard_ext/csvoutput.py,sha256=IGTGICiK_IJcldRGDhd_jNDohxFWJEWYOVxkemaY20Q,3051
@@ -25,36 +25,39 @@ lizard_ext/lizardns.py,sha256=8pztUoRS_UWN24MawwxeHEJgYh49id5PWODUBb6O72U,4184
 lizard_ext/lizardoutside.py,sha256=FGm2tbBZ17-2OCgmQlD-vobUCfQKb0FAygf86eM3xuM,336
 lizard_ext/lizardstatementcount.py,sha256=xYk6ixSIItSE1BWQXzrWmduFgGhA3VR817SNKLffyVQ,1182
 lizard_ext/lizardwordcount.py,sha256=2QYXD7-AtkkgAbi9VSidunMbSsGQ7MKYb6IT-bS-cok,7575
-lizard_ext/version.py,sha256=w0u2NprX_SchtgIWwb7GvCCipCok28egUEqabe1Qdns,181
+lizard_ext/version.py,sha256=vHwwcIFibVozQB9PB9t8W0GArqtRDBM3HzpcDelMWq8,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=_FNuZ0xNP_XHjVHH49kKorr8c7Dz1OSvNTkClG_Y444,1101
-lizard_languages/clike.py,sha256=-VKcd8VLuc0d7RXzcI7TiIzpoDzl2eB_d8d1tOv5XZc,10635
-lizard_languages/code_reader.py,sha256=8O_lm1WHcbqwDcZth_Sj7ZcjXc5xqsvPd8Q2zJXFbc0,5416
+lizard_languages/__init__.py,sha256=iIbCcjN1AzmVtqCB7caRcLWQ4CdQwyT0UAiRKCkVeL0,1273
+lizard_languages/clike.py,sha256=YgB0dHYdQ5Ae1pN00zcstkuXl94n8Ugo-aTYUNmJr7o,10723
+lizard_languages/code_reader.py,sha256=KTZ7v2MtaowH118yS2sd5GKgUW3hkLWUZ8YBiX3ZsL8,6180
 lizard_languages/csharp.py,sha256=lVi-g-0JjHagqDR5r-lRdi2BuCdtR5aer9CYY-Nzw44,478
-lizard_languages/fortran.py,sha256=5AUT3y2g7fiP59qcpU0iuSz-Q_iT9RtJpqB8ghViv4I,7279
+lizard_languages/erlang.py,sha256=AaPfIGq_phVi2hRUVHNrrmXiQSdlEktbSVOvPxORWf8,3822
+lizard_languages/fortran.py,sha256=iXxS44sNJ2_h-nvJC58Pz6AGDyVx2HdBEVF-EeYGn84,7327
 lizard_languages/gdscript.py,sha256=KwlGoODilQnFgXvODpq_XlA6fV3hGbN9fd7bsiEUn78,637
 lizard_languages/go.py,sha256=dSbWxtWve7KSRW5i9w4DxhODtJ72EcBNrgp-7Xhn0Sg,465
-lizard_languages/golike.py,sha256=FsoJbCBDOmBQodEgpxR_1-H3TjGXgniJHaIp-W_VphE,1883
+lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
 lizard_languages/java.py,sha256=mfXCRicmZFZFxPW7QuTOQtAKzOZD3d-uh4tiALcGdX4,1186
 lizard_languages/javascript.py,sha256=agcEwJbrY0tFt8rGWwsO2pH-MKXvKmt9BMlcKkUB9m4,4314
 lizard_languages/js_style_language_states.py,sha256=2_dgrXLe113xEdfATByioohGquW428pPo9gI3I1duS4,4257
 lizard_languages/js_style_regex_expression.py,sha256=1d4eK5RR0GBAFg2eDb2cKA_YHIYlxjhG7PXAuMOKnRA,743
+lizard_languages/kotlin.py,sha256=v_o2orEzA5gB9vM_0h-E4QXjrc5Yum-0K6W6_laOThc,2844
 lizard_languages/lua.py,sha256=3nqBcunBzJrhv4Iqaf8xvbyqxZy3aSxJ-IiHimHFlac,1573
 lizard_languages/objc.py,sha256=2a1teLdaXZBtCeFiIZer1j_sVx9LZ1CbF2XfnqlvLmk,2319
 lizard_languages/php.py,sha256=8OufyR2TIWyf3bXuTmp37Vwf_tEPF4YV5M3i5_jnguA,1377
-lizard_languages/python.py,sha256=HljeW-gQqmWjmc8vB7Kt75RBHq3OfKj89bpZL3QmdEY,3252
+lizard_languages/python.py,sha256=JDXqQ7SEnNSXlbK5sMyUKwCFBTEto20Wg8_ZkzYisSI,3721
 lizard_languages/ruby.py,sha256=gUrFsaS6ZJbjb9CixBHP9n0BxGOb8HsDEg7jJ2bz_80,2187
 lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
 lizard_languages/rust.py,sha256=DG2RkR9JWwcD6gIw-BPzg-Yo_lxQtSvfgHioFWIQm9o,610
 lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
 lizard_languages/script_language.py,sha256=FOzB9Rg5-XTnFDeeRRyIrp2rDomRDHhaPsxsxeCx9GU,539
-lizard_languages/swift.py,sha256=D0z87M2CoBhG83pN8M1RylZURD97qPBcVuQhx9IS3g4,2404
+lizard_languages/solidity.py,sha256=Z0GD7U5bI5eUikdy7m_iKWeFD5yXRYq4r3zycscOhJQ,553
+lizard_languages/swift.py,sha256=p8S2OAkQOx9YQ02yhoVXFkr7pMqUH1Nb3RVXPHRU_9M,2450
 lizard_languages/tnsdl.py,sha256=pGcalA_lHY362v2wwPS86seYBOOBBjvmU6vd4Yy3A9g,2803
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
 lizard_languages/typescript.py,sha256=yjUTVDkiONbg2v089pZC4wrCJSo1J5NVbQzbCfF4k6s,1547
-lizard-1.17.9.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.9.dist-info/METADATA,sha256=ZZZNi4vjB0Q9JKxuMtbUzPo_lxmFdRomQi8u_bGMgVs,15267
-lizard-1.17.9.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
-lizard-1.17.9.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.17.9.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.9.dist-info/RECORD,,
+lizard-1.17.12.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.12.dist-info/METADATA,sha256=449xh2XT8PSdqHs1N-nAQVoyKRFp7bYdJGtUNVK5SMc,15379
+lizard-1.17.12.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+lizard-1.17.12.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
+lizard-1.17.12.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.12.dist-info/RECORD,,

{lizard-1.17.9.dist-info → lizard-1.17.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.36.2)
+Generator: bdist_wheel (0.44.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

lizard.py

@@ -281,7 +281,6 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
         self.full_parameters = []
         self.filename = filename
         self.top_nesting_level = -1
-        self.length = 0
         self.fan_in = 0
         self.fan_out = 0
         self.general_fan_out = 0
@@ -302,14 +301,24 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
                         " %(name)s@%(start_line)s-%(end_line)s@%(filename)s"
                         % self.__dict__)
 
-    parameter_count = property(lambda self: len(self.full_parameters))
+    parameter_count = property(lambda self: len(self.parameters))
 
     @property
     def parameters(self):
-        matches = [re.search(r'(\w+)(\s=.*)?$', f)
+        # Exclude empty tokens as parameters. These can occur in languages
+        # allowing a trailing comma on the last parameter in an function
+        # argument list.
+        # Regex matches the parameter name, then optionally:
+        # - a default value given after an '=' sign
+        # - a type annotation given after a ':'
+        matches = [re.search(r'(\w+)(\s=.*)?(\s:.*)?$', f)
                    for f in self.full_parameters]
         return [m.group(1) for m in matches if m]
 
+    @property
+    def length(self):
+        return self.end_line - self.start_line + 1
+
     def add_to_function_name(self, app):
         self.name += app
         self.long_name += app
@@ -361,7 +370,6 @@ class NestingStack(object):
     def __init__(self):
         self.nesting_stack = []
         self.pending_function = None
-        self.function_stack = []
 
     def with_namespace(self, name):
         return ''.join([x.name_in_space for x in self.nesting_stack] + [name])
@@ -438,8 +446,6 @@ class FileInfoBuilder(object):
         self.fileinfo.nloc += count
         self.current_function.nloc += count
         self.current_function.end_line = self.current_line
-        self.current_function.length = \
-            self.current_line - self.current_function.start_line + 1
         self.newline = count > 0
 
     def try_new_function(self, name):
@@ -560,10 +566,13 @@ class FileAnalyzer(object):  # pylint: disable=R0903
         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_ext/version.py

@@ -3,4 +3,4 @@
 #
 # pylint: disable=missing-docstring,invalid-name
 
-version = "1.17.9"
+version = "1.17.12"

lizard_languages/__init__.py

@@ -1,8 +1,10 @@
 ''' programming languages of lizard '''
 
 from .clike import CLikeReader
+from .erlang import ErlangReader
 from .java import JavaReader
 from .javascript import JavaScriptReader
+from .kotlin import KotlinReader
 from .python import PythonReader
 from .objc import ObjCReader
 from .ttcn import TTCNReader
@@ -17,6 +19,7 @@ from .lua import LuaReader
 from .rust import RustReader
 from .typescript import TypeScriptReader
 from .fortran import FortranReader
+from .solidity import SolidityReader
 
 
 def languages():
@@ -37,7 +40,10 @@ def languages():
         LuaReader,
         RustReader,
         TypeScriptReader,
-        FortranReader
+        FortranReader,
+        KotlinReader,
+        SolidityReader,
+        ErlangReader,
     ]
 
 

lizard_languages/clike.py

@@ -196,7 +196,8 @@ class CLikeStates(CodeStateMachine):
             else:
                 self.next(self._state_global)
         elif len(self.bracket_stack) == 1:
-            self.context.parameter(token)
+            if token != 'void': # void is a reserved keyword, meaning no parameters
+                self.context.parameter(token)
             return
         self.context.add_to_long_function_name(token)
 

lizard_languages/code_reader.py

@@ -4,6 +4,8 @@ Base class for all language parsers
 
 import re
 from copy import copy
+from functools import reduce
+from operator import or_
 
 
 class CodeStateMachine(object):
@@ -112,7 +114,7 @@ class CodeReader:
         if not token_class:
             token_class = create_token
 
-        def _generate_tokens(source, add):
+        def _generate_tokens(source, add, flags=re.NOFLAG):
             # DO NOT put any sub groups in the regex. Good for performance
             _until_end = r"(?:\\\n|[^\n])*"
             combined_symbols = ["<<=", ">>=", "||", "&&", "===", "!==",
@@ -124,6 +126,9 @@ class CodeReader:
                 r"(?:" +
                 r"\/\*.*?\*\/" +
                 add +
+                r"|(?:\d+\')+\d+" +
+                r"|0x(?:[0-9A-Fa-f]+\')+[0-9A-Fa-f]+" +
+                r"|0b(?:[01]+\')+[01]+" +
                 r"|\w+" +
                 r"|\"(?:\\.|[^\"\\])*\"" +
                 r"|\'(?:\\.|[^\'\\])*?\'" +
@@ -135,7 +140,7 @@ class CodeReader:
                 r"|\\\n" +
                 r"|\n" +
                 r"|[^\S\n]+" +
-                r"|.)", re.M | re.S)
+                r"|.)", re.M | re.S | flags)
             macro = ""
             for match in token_pattern.finditer(source):
                 token = token_class(match)
@@ -153,7 +158,21 @@ class CodeReader:
             if macro:
                 yield macro
 
-        return _generate_tokens(source_code, addition)
+        flag_dict = {
+            'a': re.A,  # ASCII-only matching
+            'i': re.I,  # Ignore case
+            'L': re.L,  # Locale dependent
+            'm': re.M,  # Multi-line
+            's': re.S,  # Dot matches all
+            'u': re.U,  # Unicode matching
+            'x': re.X   # Verbose
+        }
+
+        pattern = re.compile(r'\(\?[aiLmsux]+\)')
+        re_flags = ''.join(opt[2:-1] for opt in pattern.findall(addition))
+        flags = reduce(or_, (flag_dict[flag] for flag in re_flags), re.NOFLAG)
+
+        return _generate_tokens(source_code, pattern.sub('', addition), flags=flags)
 
     def __call__(self, tokens, reader):
         self.context = reader.context

lizard_languages/erlang.py

@@ -0,0 +1,112 @@
+"""
+Language parser for erlang
+"""
+
+import re
+from lizard_languages.code_reader import CodeReader, CodeStateMachine
+import pygments.token as py_token
+from pygments import lex, lexers
+
+
+class ErlangReader(CodeReader):
+    # pylint: disable=R0903
+
+    ext = ['erl', 'hrl', 'es', 'escript']
+    language_names = ['erlang']
+    _conditions = {'and', 'case', 'catch', 'if', 'not', 'or', '?', 'when'}
+
+    def __init__(self, context):
+        super(ErlangReader, self).__init__(context)
+        self.parallel_states = [ErlangStates(context)]
+
+    @staticmethod
+    def get_comment_from_token(token):
+        if token.startswith("%%"):
+            return token[2:]
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        return map(lambda x: x[1], filter(lambda x: x[0] != py_token.Whitespace,
+                                          lex(source_code, lexer=lexers.get_lexer_by_name('erlang'))))
+
+
+class ErlangStates(CodeStateMachine):
+    # pylint: disable=R0903
+
+    func_name_pattern = re.compile("[a-zA-Z]+[a-zA-Z0-9_]*")
+
+    def __init__(self, context):
+        super(ErlangStates, self).__init__(context)
+        self.punctuated = False
+
+    def _state_global(self, token):
+        if token == '-':
+            self.punctuated = True
+        elif self.func_name_pattern.match(token) and not self.punctuated:
+            self.context.push_new_function(token)
+            self._state = self._state_after_name
+        elif token == 'end':
+            self._state = self._state_nested_end
+        elif token == '.' or token == ';':
+            self.statemachine_return()
+        else:
+            self.punctuated = False
+
+    def _state_after_name(self, token):
+        if token == '(':
+            self._state = self._state_start_of_params
+            self.context.add_to_long_function_name(token)
+            self.lbr = 1
+            self.rbr = 0
+        else:
+            self.func_match_failed(token)
+
+    def _state_start_of_params(self, token):
+        if token == ')':
+            self.rbr += 1
+            if self.lbr == self.rbr:
+                self._state = self._state_end_of_params
+                self.context.add_to_long_function_name(" " + token)
+                self.punctuated = False
+                return
+        if token == '(':
+            self.lbr += 1
+        self.context.parameter(token)
+
+    def _state_end_of_params(self, token):
+        if token == '-':
+            self.punctuated = True
+        elif token == '>' and self.punctuated:
+            if len(self.context.stacked_functions) <= 1 or \
+                    self.context.current_function.name == 'fun':
+                self.next(self._state_func_first_line, token)
+        else:
+            self.func_match_failed(token)
+
+    def _state_func_first_line(self, _):
+        def callback():
+            self._state = self._state_global
+            self.context.end_of_function()
+
+        self.sub_state(self.statemachine_clone(), callback)
+        self.punctuated = False
+
+    def _state_nested_end(self, token):
+        if token == '.' or token == ',':
+            if len(self.context.stacked_functions) > 1 \
+                    and self.context.stacked_functions[-1].name == 'fun':
+                self.statemachine_return()
+                return
+
+        self._state = self._state_global
+
+    def func_match_failed(self, token):
+        self.punctuated = False
+        self._state = self._state_global
+        curr_cyc_comp = self.context.current_function.cyclomatic_complexity - 1
+        if self.context.stacked_functions:
+            self.context.current_function = self.context.stacked_functions.pop()
+        else:
+            self.context.current_function = self.context.global_pseudo_function
+        self.context.add_condition(curr_cyc_comp)
+        self.next(self._state_global, token)

lizard_languages/fortran.py

@@ -35,11 +35,10 @@ class FortranReader(CodeReader, FortranCommentsMixin):
         _until_end = r'(?:\\\n|[^\n])*'
         return CodeReader.generate_tokens(
             source_code,
-            r'(?i)' +
-            r'|\/\/' +
+            r'(?i)'
+            r'\/\/' +
             r'|\#' + _until_end +
             r'|\!' + _until_end +
-            r'|^C' + _until_end +
             r'|^\*' + _until_end +
             r'|\.OR\.' +
             r'|\.AND\.' +
@@ -124,6 +123,8 @@ class FortranStates(CodeStateMachine):
             self.context.add_bare_nesting()
         elif token_upper.replace(' ', '') == 'ELSEIF':
             self.context.pop_nesting()
+            if token_upper == 'ELSEIF':
+                self.context.add_condition()
             self._state = self._if
         elif token_upper == 'END' or self._ends.match(token):
             self.context.pop_nesting()

lizard_languages/golike.py

@@ -13,15 +13,40 @@ class GoLikeStates(CodeStateMachine):  # pylint: disable=R0903
         if token == self.FUNC_KEYWORD:
             self._state = self._function_name
             self.context.push_new_function('')
+        elif token == 'type':
+            self._state = self._type_definition
         elif token in '{':
             self.sub_state(self.statemachine_clone())
         elif token in '}':
             self.statemachine_return()
 
+    def _type_definition(self, token):
+        self._state = self._after_type_name
+
+    def _after_type_name(self, token):
+        if token == 'struct':
+            self._state = self._struct_definition
+        elif token == 'interface':
+            self._state = self._interface_definition
+        else:
+            self._state = self._state_global
+
+    @CodeStateMachine.read_inside_brackets_then("{}", "_state_global")
+    def _struct_definition(self, tokens):
+        pass
+
+    @CodeStateMachine.read_inside_brackets_then("{}", "_state_global")
+    def _interface_definition(self, tokens):
+        pass
+
     def _function_name(self, token):
         if token != '`':
             if token == '(':
-                return self.next(self._member_function, token)
+                if len(self.context.stacked_functions) > 0\
+                        and self.context.stacked_functions[-1].name != '*global*':
+                    return self.next(self._function_dec, token)
+                else:
+                    return self.next(self._member_function, token)
             if token == '{':
                 return self.next(self._expect_function_impl, token)
             self.context.add_to_function_name(token)
@@ -49,7 +74,8 @@ class GoLikeStates(CodeStateMachine):  # pylint: disable=R0903
             self.context.parameter(token)
 
     def _expect_function_impl(self, token):
-        self.next_if(self._function_impl, token, '{')
+        if token == '{' and self.last_token != 'interface':
+            self.next(self._function_impl, token)
 
     def _function_impl(self, _):
         def callback():

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/python.py

@@ -53,7 +53,9 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
                         current_leading_spaces += count_spaces(token)
                     else:
                         if not token.startswith('#'):
-                            indents.set_nesting(current_leading_spaces, token)
+                            current_function = self.context.current_function
+                            if current_function.name == '*global*' or current_function.long_name.endswith(')'):
+                                indents.set_nesting(current_leading_spaces, token)
                         reading_leading_space = False
             else:
                 reading_leading_space = True
@@ -82,6 +84,8 @@ class PythonStates(CodeStateMachine):  # pylint: disable=R0903
     def _dec(self, token):
         if token == ')':
             self._state = self._state_colon
+        elif token == '[':
+            self._state = self._state_parameterized_type_annotation
         else:
             self.context.parameter(token)
             return
@@ -98,3 +102,8 @@ class PythonStates(CodeStateMachine):  # pylint: disable=R0903
         if token.startswith('"""') or token.startswith("'''"):
             self.context.add_nloc(-token.count('\n') - 1)
         self._state_global(token)
+
+    def _state_parameterized_type_annotation(self, token):
+        self.context.add_to_long_function_name(" " + token)
+        if token == ']':
+            self._state = self._dec

lizard_languages/solidity.py

@@ -0,0 +1,22 @@
+'''
+Language parser for Solidity
+'''
+
+from .clike import CCppCommentsMixin
+from .code_reader import CodeReader
+from .golike import GoLikeStates
+
+
+class SolidityReader(CodeReader, CCppCommentsMixin):
+
+    ext = ['sol']
+    language_names = ['solidity']
+    _conditions = set(['if', 'for', 'while', '&&', '||', '?'])
+
+    def __init__(self, context):
+        super(SolidityReader, self).__init__(context)
+        self.parallel_states = [SolidityStates(context)]
+
+
+class SolidityStates(GoLikeStates):  # pylint: disable=R0903
+    FUNC_KEYWORD = 'function'

lizard_languages/swift.py

@@ -7,7 +7,24 @@ from .clike import CCppCommentsMixin
 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 @@ class SwiftReader(CodeReader, CCppCommentsMixin):
             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):