lizard 1.17.16__tar.gz → 1.17.18__tar.gz

{lizard-1.17.16 → lizard-1.17.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.16
+Version: 1.17.18
 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/

{lizard-1.17.16 → lizard-1.17.18}/lizard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.16
+Version: 1.17.18
 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/

{lizard-1.17.16 → lizard-1.17.18}/lizard.py

@@ -284,6 +284,7 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
         self.fan_in = 0
         self.fan_out = 0
         self.general_fan_out = 0
+        self.max_nesting_depth = 0  # Initialize max_nesting_depth to 0
 
     @property
     def name_in_space(self):

{lizard-1.17.16 → lizard-1.17.18}/lizard_ext/version.py

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

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/clike.py

@@ -30,6 +30,14 @@ class CLikeReader(CodeReader, CCppCommentsMixin):
                 CLikeNestingStackStates(context),
                 CppRValueRefStates(context))
 
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        # Add pattern for floating point literals to the token generation
+        addition = r"|(?:\d*\.\d+(?:[eE][-+]?\d+)?)" + \
+                  r"|(?:\d+\.(?:\d+)?(?:[eE][-+]?\d+)?)" + \
+                  addition
+        return CodeReader.generate_tokens(source_code, addition, token_class)
+
     def preprocess(self, tokens):
         tilde = False
         for token in tokens:

lizard-1.17.18/lizard_languages/go.py

@@ -0,0 +1,45 @@
+'''
+Language parser for Go lang
+'''
+
+from .code_reader import CodeReader
+from .clike import CCppCommentsMixin
+from .golike import GoLikeStates
+
+
+class GoReader(CodeReader, CCppCommentsMixin):
+    # pylint: disable=R0903
+
+    ext = ['go']
+    language_names = ['go']
+
+    def __init__(self, context):
+        super(GoReader, self).__init__(context)
+        self.parallel_states = [GoStates(context)]
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        addition = addition + r"|`[^`]*`"  # Add support for backtick-quoted strings
+        return CodeReader.generate_tokens(source_code, addition, token_class)
+
+    def __call__(self, tokens, reader):
+        self.context = reader.context
+        for token in tokens:
+            # Skip counting ? in backtick-quoted strings
+            if token.startswith('`') and token.endswith('`'):
+                for state in self.parallel_states:
+                    state(token)
+                yield token
+                continue
+            
+            # For non-backtick tokens, process normally
+            for state in self.parallel_states:
+                state(token)
+            yield token
+        for state in self.parallel_states:
+            state.statemachine_before_return()
+        self.eof()
+
+
+class GoStates(GoLikeStates):  # pylint: disable=R0903
+    pass

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/java.py

@@ -2,6 +2,7 @@
 Language parser for Java
 '''
 
+from lizard_languages.code_reader import CodeStateMachine
 from .clike import CLikeReader, CLikeStates, CLikeNestingStackStates
 
 
@@ -29,6 +30,11 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
         if token == '{':
             self._state_dec_to_imp(token)
 
+    def _state_imp(self, token):
+        def callback():
+            self.next(self._state_global)
+        self.sub_state(JavaFunctionBodyStates(self.context), callback, token)
+
     def try_new_function(self, name):
         # Don't create a function for record compact constructor
         if self.is_record and name == self.class_name:
@@ -40,15 +46,19 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
         if self.class_name and self.context.current_function:
             self.context.current_function.name = f"{self.class_name}::{name}"
 
-    def _state_global(self, token):
-        if token == '@':
-            self._state = self._state_decorator
-            return
+    def _try_start_a_class(self, token):
         if token in ("class", "record", "enum"):
             self.class_name = None
             self.is_record = token == "record"
             self.in_record_constructor = False
             self._state = self._state_class_declaration
+            return True
+
+    def _state_global(self, token):
+        if token == '@':
+            self._state = self._state_decorator
+            return
+        if self._try_start_a_class(token):
             return
         if not self.in_record_constructor:  # Only process as potential function if not in record constructor
             super(JavaStates, self)._state_global(token)
@@ -65,7 +75,9 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
 
     def _state_class_declaration(self, token):
         if token == '{':
-            self._state = self._state_global
+            def callback():
+                self._state = self._state_global
+            self.sub_state(JavaClassBodyStates(self.class_name, self.is_record, self.context), callback, token)
         elif token == '(':  # Record parameters
             self._state = self._state_record_parameters
         elif token[0].isalpha():
@@ -87,3 +99,44 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
         if token == '}':
             self.in_record_constructor = False
             self._state = self._state_global
+
+class JavaFunctionBodyStates(JavaStates):
+    def __init__(self, context):
+        super(JavaFunctionBodyStates, self).__init__(context)
+
+    @CodeStateMachine.read_inside_brackets_then("{}", "_state_dummy")
+    @CodeStateMachine.read_inside_brackets_then("()", "_state_dummy")
+    def _state_global(self, token):
+        if token == "new":
+            self.next(self._state_new)
+        self._try_start_a_class(token)
+        if self.br_count == 0:
+            self.statemachine_return()
+
+    def _state_dummy(self, _):
+        pass
+
+    def _state_new(self, token):
+        self.next(self._state_new_parameters)
+
+    def _state_new_parameters(self, token):
+        if token == "(":
+            self.sub_state(JavaFunctionBodyStates(self.context), None, token)
+            return
+        if token == "{":
+            def callback():
+                self.next(self._state_global)
+            self.sub_state(JavaClassBodyStates("(anonymous)", False, self.context), callback, token)
+            return
+        self.next(self._state_global)
+
+class JavaClassBodyStates(JavaStates):
+    def __init__(self, class_name, is_record, context):
+        super(JavaClassBodyStates, self).__init__(context)
+        self.class_name = class_name
+        self.is_record = is_record
+
+    def _state_global(self, token):
+        super()._state_global(token)
+        if token == '}':
+            self.statemachine_return()

lizard-1.17.18/lizard_languages/javascript.py

@@ -0,0 +1,15 @@
+'''
+Language parser for JavaScript
+'''
+
+from .typescript import TypeScriptReader 
+
+
+class JavaScriptReader(TypeScriptReader):
+    # pylint: disable=R0903
+
+    ext = ['js', 'cjs', 'mjs']
+    language_names = ['javascript', 'js']
+
+    def __init__(self, context):
+        super(JavaScriptReader, self).__init__(context)

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/jsx.py

@@ -8,6 +8,20 @@ from .code_reader import CodeReader
 from .js_style_regex_expression import js_style_regex_expression
 
 
+class TSXTokenizer(JSTokenizer):
+    def __init__(self):
+        super().__init__()
+
+    def process_token(self, token):
+        if token == "<":
+            from .jsx import XMLTagWithAttrTokenizer  # Import only when needed
+            self.sub_tokenizer = XMLTagWithAttrTokenizer()
+            return
+    
+        for tok in super().process_token(token):
+            yield tok
+
+
 class JSXMixin:
     '''Base mixin class for JSX/TSX shared functionality'''
     @staticmethod
@@ -17,7 +31,7 @@ class JSXMixin:
             r"|(?:\$\w+)" + \
             r"|(?:\<\/\w+\>)" + \
             r"|`.*?`"
-        js_tokenizer = JSTokenizer()
+        js_tokenizer = TSXTokenizer()
         for token in CodeReader.generate_tokens(
                 source_code, addition, token_class):
             for tok in js_tokenizer(token):
@@ -102,7 +116,7 @@ class XMLTagWithAttrTokenizer(Tokenizer):
             self.state = self._after_tag
         elif token == "{":
             self.cache.append("}")
-            self.sub_tokenizer = JSTokenizer()
+            self.sub_tokenizer = TSXTokenizer()
             self.state = self._after_tag
 
     def _body(self, token):
@@ -116,7 +130,7 @@ class XMLTagWithAttrTokenizer(Tokenizer):
             return self.flush()
 
         if token == '{':
-            self.sub_tokenizer = JSTokenizer()
+            self.sub_tokenizer = TSXTokenizer()
             return self.flush()
 
 

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/python.py

@@ -42,7 +42,8 @@ class PythonReader(CodeReader, ScriptLanguageMixIn):
     def generate_tokens(source_code, addition='', token_class=None):
         return ScriptLanguageMixIn.generate_common_tokens(
             source_code,
-            r"|\'\'\'.*?\'\'\'" + r'|\"\"\".*?\"\"\"',
+            r"|(?:\"\"\"(?:\\.|[^\"]|\"(?!\"\")|\"\"(?!\"))*\"\"\")" + 
+            r"|(?:\'\'\'(?:\\.|[^\']|\'(?!\'\')|\'\'(?!\'))*\'\'\')",
             token_class)
 
     def preprocess(self, tokens):

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/ruby.py

@@ -9,11 +9,12 @@ from .script_language import ScriptLanguageMixIn
 
 class MyToken(str):
     def __new__(cls, value, *_):
-        return super(MyToken, cls).__new__(cls, value.group(0))
+        val = value.group(0) if hasattr(value, 'group') else value
+        return super(MyToken, cls).__new__(cls, val)
 
     def __init__(self, value):
         super(MyToken, self).__init__()
-        self.begin = value.start()
+        self.begin = value.start() if hasattr(value, 'start') else 0
 
 
 class RubyReader(RubylikeReader):

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/tsx.py

@@ -2,9 +2,8 @@
 Language parser for TSX
 '''
 
-from .typescript import TypeScriptReader, TypeScriptStates, JSTokenizer
+from .typescript import TypeScriptReader
 from .jsx import JSXMixin
-from .code_reader import CodeReader
 from .js_style_regex_expression import js_style_regex_expression
 
 

{lizard-1.17.16 → lizard-1.17.18}/lizard_languages/typescript.py

@@ -37,10 +37,6 @@ class JSTokenizer(Tokenizer):
         self.depth = 1
 
     def process_token(self, token):
-        if token == "<":
-            from .jsx import XMLTagWithAttrTokenizer  # Import only when needed
-            self.sub_tokenizer = XMLTagWithAttrTokenizer()
-            return
         if token == "{":
             self.depth += 1
         elif token == "}":
@@ -115,10 +111,18 @@ class TypeScriptTypeAnnotationStates(CodeStateMachine):
             self.next(self._state_simple_type, token)
 
     def _state_simple_type(self, token):
-        if token in '{=;':
+        print(token)
+        if token == '<':
+            print(token)
+            self.next(self._state_generic_type, token)
+        elif token in '{=;':
             self.saved_token = token
             self.statemachine_return()
 
     @CodeStateMachine.read_inside_brackets_then("{}")
     def _inline_type_annotation(self, _):
         self.statemachine_return()
+
+    @CodeStateMachine.read_inside_brackets_then("<>")
+    def _state_generic_type(self, token):
+        self.statemachine_return()

{lizard-1.17.16 → lizard-1.17.18}/test/testOutput.py

@@ -86,6 +86,15 @@ class TestWarningOutput(StreamStdoutTestCase):
         self.option.sorting = ['cyclomatic_complexity']
         print_warnings(self.option, self.scheme, (x for x in []))
 
+    def test_warning_when_max_nesting_depth_missing(self):
+        self.foo.cyclomatic_complexity = 30
+        # Intentionally not setting max_nesting_depth
+        fileSummary = FileInformation("FILENAME", 123, [self.foo])
+        scheme = OutputScheme([Ext()])
+        count = print_clang_style_warning([fileSummary], self.option, scheme, None)
+        self.assertIn("FILENAME:100: warning: foo has 1 NLOC, 30 CCN, 1 token, 0 PARAM, 1 length", sys.stdout.stream)
+        self.assertEqual(1, count)
+
 
 class TestFileInformationOutput(StreamStdoutTestCase):
 

lizard-1.17.16/lizard_languages/go.py

@@ -1,22 +0,0 @@
-'''
-Language parser for Go lang
-'''
-
-from .code_reader import CodeReader
-from .clike import CCppCommentsMixin
-from .golike import GoLikeStates
-
-
-class GoReader(CodeReader, CCppCommentsMixin):
-    # pylint: disable=R0903
-
-    ext = ['go']
-    language_names = ['go']
-
-    def __init__(self, context):
-        super(GoReader, self).__init__(context)
-        self.parallel_states = [GoStates(context)]
-
-
-class GoStates(GoLikeStates):  # pylint: disable=R0903
-    pass

lizard-1.17.16/lizard_languages/javascript.py

@@ -1,19 +0,0 @@
-'''
-Language parser for JavaScript
-'''
-
-from .code_reader import CodeReader
-from .clike import CCppCommentsMixin
-from .js_style_regex_expression import js_style_regex_expression
-from .js_style_language_states import JavaScriptStyleLanguageStates
-from .typescript import TypeScriptReader, JSTokenizer
-
-
-class JavaScriptReader(TypeScriptReader):
-    # pylint: disable=R0903
-
-    ext = ['js']
-    language_names = ['javascript', 'js']
-
-    def __init__(self, context):
-        super(JavaScriptReader, self).__init__(context)