lizard 1.17.10__tar.gz → 1.17.13__tar.gz

{lizard-1.17.10 → lizard-1.17.13}/PKG-INFO

@@ -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,10 +23,10 @@ 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
@@ -66,6 +66,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 +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
 ------------
@@ -112,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.10 → lizard-1.17.13}/README.rst

@@ -35,6 +35,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
@@ -57,7 +59,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
 ------------
@@ -81,7 +83,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 → lizard-1.17.13}/lizard.egg-info/PKG-INFO

@@ -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,10 +23,10 @@ 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
@@ -66,6 +66,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 +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
 ------------
@@ -112,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.10 → lizard-1.17.13}/lizard.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ lizard.egg-info/PKG-INFO
 lizard.egg-info/SOURCES.txt
 lizard.egg-info/dependency_links.txt
 lizard.egg-info/entry_points.txt
+lizard.egg-info/requires.txt
 lizard.egg-info/top_level.txt
 lizard_ext/__init__.py
 lizard_ext/auto_open.py
@@ -40,6 +41,7 @@ lizard_languages/__init__.py
 lizard_languages/clike.py
 lizard_languages/code_reader.py
 lizard_languages/csharp.py
+lizard_languages/erlang.py
 lizard_languages/fortran.py
 lizard_languages/gdscript.py
 lizard_languages/go.py
@@ -58,6 +60,7 @@ lizard_languages/rubylike.py
 lizard_languages/rust.py
 lizard_languages/scala.py
 lizard_languages/script_language.py
+lizard_languages/solidity.py
 lizard_languages/swift.py
 lizard_languages/tnsdl.py
 lizard_languages/ttcn.py

lizard-1.17.13/lizard.egg-info/requires.txt

@@ -0,0 +1 @@
+pygments

{lizard-1.17.10 → lizard-1.17.13}/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-1.17.10 → lizard-1.17.13}/lizard_ext/version.py

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

{lizard-1.17.10 → lizard-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-1.17.10 → lizard-1.17.13}/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-1.17.10 → lizard-1.17.13}/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-1.17.13/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-1.17.10 → lizard-1.17.13}/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-1.17.10 → lizard-1.17.13}/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-1.17.10 → lizard-1.17.13}/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-1.17.13/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-1.17.10 → lizard-1.17.13}/setup.py

@@ -87,14 +87,15 @@ setup(
                     'Programming Language :: JavaScript',
                     'Programming Language :: Objective C',
                     'Programming Language :: Python',
-                    'Programming Language :: Python :: 2.7',
-                    'Programming Language :: Python :: 3.4',
-                    'Programming Language :: Python :: 3.5',
-                    'Programming Language :: Python :: 3.6'],
+                    'Programming Language :: Python :: 3.8',
+                    'Programming Language :: Python :: 3.9',
+                    'Programming Language :: Python :: 3.10',
+                    'Programming Language :: Python :: 3.11'],
     cmdclass={'version': VersionCommand},
     packages=['lizard_ext', 'lizard_languages'],
     #data_files=[('lizard_ext', [])],
     py_modules=['lizard'],
+    install_requires=['pygments'],
     entry_points={'console_scripts': ['lizard = lizard:main']},
     author='Terry Yin',
     author_email='terry@odd-e.com',

{lizard-1.17.10 → lizard-1.17.13}/test/testLanguages.py

@@ -1,5 +1,6 @@
 import unittest
-from lizard_languages import get_reader_for, CLikeReader, JavaReader, ObjCReader, JavaScriptReader, ScalaReader, GDScriptReader
+from lizard_languages import get_reader_for, CLikeReader, JavaReader, ObjCReader, JavaScriptReader, ScalaReader,\
+    GDScriptReader, SolidityReader, ErlangReader
 
 
 class TestLanguageChooser(unittest.TestCase):
@@ -29,3 +30,9 @@ class TestLanguageChooser(unittest.TestCase):
 
     def test_unknown_extension(self):
         self.assertEqual(None, get_reader_for("a.unknown"))
+
+    def test_Solidity(self):
+        self.assertEqual(SolidityReader, get_reader_for("a.sol"))
+
+    def test_erlang(self):
+        self.assertEqual(ErlangReader, get_reader_for("a.erl"))

{lizard-1.17.10 → lizard-1.17.13}/test/testOutputCSV.py

@@ -22,7 +22,7 @@ class TestCSVOutput(StreamStdoutTestCase):
         options_mock.verbose = True
         options_mock.extensions = []
         csv_output(AllResult([self.fileSummary]), options_mock)
-        self.assertRegexpMatches(sys.stdout.stream,
+        self.assertRegex(sys.stdout.stream,
                                  r"NLOC,CCN,token,PARAM,length,location,file,function,long_name,start,end")
 
     def test_csv_header_with_extension(self):
@@ -35,7 +35,7 @@ class TestCSVOutput(StreamStdoutTestCase):
         results = AllResult([self.fileSummary])
         results.result[0].function_list[0].exit_count = 1
         csv_output(results, options_mock)
-        self.assertRegexpMatches(sys.stdout.stream,
+        self.assertRegex(sys.stdout.stream,
                                  r"NLOC,CCN,token,PARAM,length,location,file,function,long_name,start,end,exits")
 
     def test_csv_no_header(self):

{lizard-1.17.10 → lizard-1.17.13}/test/testOutputHTML.py

@@ -17,6 +17,5 @@ class TestHTMLOutput(StreamStdoutTestCase):
 
     def test_should_have_html_body(self):
         html_output([self.fileSummary], self.option, None, AllResult)
-        self.assertRegexpMatches(sys.stdout.stream,
-                                 r"\<html\>")
+        self.assertRegex(sys.stdout.stream, r"\<html\>")