lizard 1.17.10__py2.py3-none-any.whl → 1.17.13__py2.py3-none-any.whl

{lizard-1.17.10.dist-info → lizard-1.17.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.10
+Version: 1.17.13
 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/
@@ -23,11 +23,12 @@ 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
+Requires-Dist: pygments
 
 |Web Site| Lizard
 =================
@@ -66,6 +67,8 @@ A list of supported languages:
 -  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
@@ -88,7 +91,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
 ------------
@@ -112,7 +115,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.10.dist-info → lizard-1.17.13.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lizard.py,sha256=y8kU4WIi5E-S8N99lTcp_TbdXYqDngi0sjNwciv6GMs,38272
+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,16 +25,17 @@ 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=7IvYS3aXsjeGGL5lIzocgukLm0cYtzRbMhvOLb8hZL0,182
+lizard_ext/version.py,sha256=cV8SELFV7_EfiIev7wFOD2wke6gb9on99S4p_3CSUAc,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=OT7nxb-UdSB_J5xHat5vkQvEJxmMDSTdy5ZwjuHBj20,1156
-lizard_languages/clike.py,sha256=-VKcd8VLuc0d7RXzcI7TiIzpoDzl2eB_d8d1tOv5XZc,10635
-lizard_languages/code_reader.py,sha256=532zy1K5hBoFJR6KYsKhpkGCsBcqtMlvdE6KUd8JrPw,5452
+lizard_languages/__init__.py,sha256=iIbCcjN1AzmVtqCB7caRcLWQ4CdQwyT0UAiRKCkVeL0,1273
+lizard_languages/clike.py,sha256=YgB0dHYdQ5Ae1pN00zcstkuXl94n8Ugo-aTYUNmJr7o,10723
+lizard_languages/code_reader.py,sha256=95_juW_8vcTShV_BoWNmBiz5CmCk59VxRi0QWF67Bsw,6164
 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
@@ -43,19 +44,20 @@ lizard_languages/kotlin.py,sha256=v_o2orEzA5gB9vM_0h-E4QXjrc5Yum-0K6W6_laOThc,28
 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=GQFA0pqrDqJPPcNYQu3E4wh2rmUwph1P8hvwqsxgSIc,3445
+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/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.10.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.10.dist-info/METADATA,sha256=8Sxwujdsg565s5lDDGCVRA_PRNKgrR-s2OQVb3Cfwwo,15360
-lizard-1.17.10.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110
-lizard-1.17.10.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
-lizard-1.17.10.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.10.dist-info/RECORD,,
+lizard-1.17.13.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.13.dist-info/METADATA,sha256=XwvrQB7WJSc664t-xQovyEcKuufzKizZCnyUPSTowq8,15403
+lizard-1.17.13.dist-info/WHEEL,sha256=fS9sRbCBHs7VFcwJLnLXN1MZRR0_TVTxvXKzOnaSFs8,110
+lizard-1.17.13.dist-info/entry_points.txt,sha256=pPMMwoHAltzGHqR2WeJQItLeeyR7pbX5R2S_POC-xoo,40
+lizard-1.17.13.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.13.dist-info/RECORD,,

{lizard-1.17.10.dist-info → lizard-1.17.13.dist-info}/WHEEL

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

lizard.py

@@ -301,11 +301,17 @@ 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]
 
@@ -364,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])

lizard_ext/version.py

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

lizard_languages/__init__.py

@@ -1,6 +1,7 @@
 ''' programming languages of lizard '''
 
 from .clike import CLikeReader
+from .erlang import ErlangReader
 from .java import JavaReader
 from .javascript import JavaScriptReader
 from .kotlin import KotlinReader
@@ -18,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():
@@ -39,7 +41,9 @@ def languages():
         RustReader,
         TypeScriptReader,
         FortranReader,
-        KotlinReader
+        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=0):
             # DO NOT put any sub groups in the regex. Good for performance
             _until_end = r"(?:\\\n|[^\n])*"
             combined_symbols = ["<<=", ">>=", "||", "&&", "===", "!==",
@@ -125,6 +127,8 @@ class CodeReader:
                 r"\/\*.*?\*\/" +
                 add +
                 r"|(?:\d+\')+\d+" +
+                r"|0x(?:[0-9A-Fa-f]+\')+[0-9A-Fa-f]+" +
+                r"|0b(?:[01]+\')+[01]+" +
                 r"|\w+" +
                 r"|\"(?:\\.|[^\"\\])*\"" +
                 r"|\'(?:\\.|[^\'\\])*?\'" +
@@ -136,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)
@@ -154,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), 0)
+
+        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/python.py

@@ -84,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
@@ -100,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'