lizard 1.17.19__tar.gz → 1.17.21__tar.gz

{lizard-1.17.19 → lizard-1.17.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.19
+Version: 1.17.21
 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/
@@ -70,6 +70,7 @@ A list of supported languages:
 -  Solidity
 -  Erlang
 -  Zig
+-  Perl
 
 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-1.17.19 → lizard-1.17.21}/README.rst

@@ -39,6 +39,7 @@ A list of supported languages:
 -  Solidity
 -  Erlang
 -  Zig
+-  Perl
 
 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-1.17.19 → lizard-1.17.21}/lizard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.19
+Version: 1.17.21
 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/
@@ -70,6 +70,7 @@ A list of supported languages:
 -  Solidity
 -  Erlang
 -  Zig
+-  Perl
 
 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-1.17.19 → lizard-1.17.21}/lizard.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ lizard_languages/jsx.py
 lizard_languages/kotlin.py
 lizard_languages/lua.py
 lizard_languages/objc.py
+lizard_languages/perl.py
 lizard_languages/php.py
 lizard_languages/python.py
 lizard_languages/ruby.py

{lizard-1.17.19 → lizard-1.17.21}/lizard_ext/version.py

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

{lizard-1.17.19 → lizard-1.17.21}/lizard_languages/__init__.py

@@ -24,6 +24,7 @@ from .solidity import SolidityReader
 from .jsx import JSXReader
 from .tsx import TSXReader
 from .vue import VueReader
+from .perl import PerlReader
 
 
 def languages():
@@ -52,6 +53,7 @@ def languages():
         JSXReader,
         TSXReader,
         VueReader,
+        PerlReader,
     ]
 
 

{lizard-1.17.19 → lizard-1.17.21}/lizard_languages/java.py

@@ -123,7 +123,6 @@ class JavaFunctionBodyStates(JavaStates):
         if token == "(":
             self.sub_state(JavaFunctionBodyStates(self.context), None, token)
             return
-        print(token)
         if token == "{":
             def callback():
                 self.next(self._state_global)

{lizard-1.17.19 → lizard-1.17.21}/lizard_languages/js_style_language_states.py

@@ -34,6 +34,8 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
         elif token in ('else', 'do', 'try', 'final'):
             self.next(self._expecting_statement_or_block)
         elif token in ('=>',):
+            if self.function_name:
+                self._push_function_to_stack()
             self._state = self._arrow_function
         elif token == '=':
             self.function_name = self.last_tokens
@@ -100,7 +102,13 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
 
     def _arrow_function(self, token):
         self._push_function_to_stack()
-        self.next(self._state_global, token)
+        # Handle arrow function body
+        if token == '{':
+            # Block body
+            self.next(self._state_global, token)
+        else:
+            # Expression body
+            self.next(self._state_global, token)
 
     def _function(self, token):
         if token == '*':

lizard-1.17.21/lizard_languages/jsx.py

@@ -0,0 +1,265 @@
+'''
+Language parser for JSX
+'''
+
+from .javascript import JavaScriptReader
+from .typescript import JSTokenizer, Tokenizer
+from .code_reader import CodeReader
+from .js_style_regex_expression import js_style_regex_expression
+from .js_style_language_states import JavaScriptStyleLanguageStates
+
+
+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
+        
+        if token == "=>":
+            # Special handling for arrow functions
+            yield token
+            return
+    
+        for tok in super().process_token(token):
+            yield tok
+
+
+class JSXMixin:
+    '''Base mixin class for JSX/TSX shared functionality'''
+    @staticmethod
+    @js_style_regex_expression
+    def generate_tokens(source_code, addition='', token_class=None):
+        addition = addition +\
+            r"|(?:\$\w+)" + \
+            r"|(?:\<\/\w+\>)" + \
+            r"|(?:=>)" + \
+            r"|`.*?`"
+        js_tokenizer = TSXTokenizer()
+        for token in CodeReader.generate_tokens(
+                source_code, addition, token_class):
+            for tok in js_tokenizer(token):
+                yield tok
+
+    def _expecting_func_opening_bracket(self, token):
+        if token == '<':
+            self.next(self._expecting_jsx)
+            return
+        if token == '=>':
+            # Handle arrow functions in JSX attributes
+            self._handle_arrow_function()
+            return
+        super()._expecting_func_opening_bracket(token)
+
+    def _handle_arrow_function(self):
+        # Process arrow function in JSX context
+        self.context.add_to_long_function_name(" => ")
+        
+        # Store the current function
+        current_function = self.context.current_function
+        
+        # Create a new anonymous function
+        self.context.restart_new_function('(anonymous)')
+        
+        # Set up for the arrow function body
+        def callback():
+            # Return to the original function when done
+            self.context.current_function = current_function
+            
+        self.sub_state(self.__class__(self.context), callback)
+
+    def _expecting_arrow_function_body(self, token):
+        if token == '{':
+            # Arrow function with block body
+            self.next(self._function_body)
+        else:
+            # Arrow function with expression body
+            self.next(self._expecting_func_opening_bracket)
+            
+    def _function_body(self, token):
+        if token == '}':
+            # End of arrow function body
+            self.context.end_of_function()
+            self.next(self._expecting_func_opening_bracket)
+
+    def _expecting_jsx(self, token):
+        if token == '>':
+            self.next(self._expecting_func_opening_bracket)
+
+
+class JSXJavaScriptStyleLanguageStates(JavaScriptStyleLanguageStates):
+    def __init__(self, context):
+        super(JSXJavaScriptStyleLanguageStates, self).__init__(context)
+        
+    def _state_global(self, token):
+        if token == 'const' or token == 'let' or token == 'var':
+            # Remember that we're in a variable declaration
+            self.in_variable_declaration = True
+            super()._state_global(token)
+            return
+            
+        if hasattr(self, 'in_variable_declaration') and self.in_variable_declaration:
+            if token == '=':
+                # We're in a variable assignment
+                self.function_name = self.last_tokens
+                super()._state_global(token)
+                return
+            elif token == '=>':
+                # We're in an arrow function with a variable assignment
+                self._push_function_to_stack()
+                self._state = self._arrow_function
+                return
+            elif token == ';' or self.context.newline:
+                # End of variable declaration
+                self.in_variable_declaration = False
+                
+        super()._state_global(token)
+        
+    def _expecting_func_opening_bracket(self, token):
+        if token == ':':
+            # Handle type annotations like TypeScript does
+            self._consume_type_annotation()
+            return
+        super()._expecting_func_opening_bracket(token)
+        
+    def _consume_type_annotation(self):
+        # Skip over type annotations (simplified version of TypeScript's behavior)
+        def skip_until_terminator(token):
+            if token in ['{', '=', ';', ')', '(', '=>']:
+                self.next(self._state_global, token)
+                return True
+            return False
+            
+        self.next(skip_until_terminator)
+
+
+class JSXReader(JavaScriptReader, JSXMixin):
+    # pylint: disable=R0903
+
+    ext = ['jsx']
+    language_names = ['jsx']
+
+    @staticmethod
+    @js_style_regex_expression
+    def generate_tokens(source_code, addition='', token_class=None):
+        # Add support for JSX syntax patterns
+        addition = addition + \
+            r"|(?:<[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)*>)" + \
+            r"|(?:<\/[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)*>)"
+        return JSXMixin.generate_tokens(source_code, addition, token_class)
+
+    def __init__(self, context):
+        super(JSXReader, self).__init__(context)
+        # Use our custom JavaScriptStyleLanguageStates subclass
+        self.parallel_states = [JSXJavaScriptStyleLanguageStates(context)]
+
+
+class XMLTagWithAttrTokenizer(Tokenizer):
+    def __init__(self):
+        super(XMLTagWithAttrTokenizer, self).__init__()
+        self.tag = None
+        self.state = self._global_state
+        self.cache = ['<']
+        self.brace_count = 0  # Track nested braces for complex expressions
+        self.arrow_function_detected = False  # Track if we've detected an arrow function
+
+    def process_token(self, token):
+        self.cache.append(token)
+        if not token.isspace():
+            result = self.state(token)
+            if result is not None:
+                return result
+        return ()
+
+    def abort(self):
+        self.stop()
+        return self.cache
+
+    def flush(self):
+        tmp, self.cache = self.cache, []
+        return [''.join(tmp)]
+
+    def _global_state(self, token):
+        if not isidentifier(token):
+            return self.abort()
+        self.tag = token
+        self.state = self._after_tag
+
+    def _after_tag(self, token):
+        if token == '>':
+            self.state = self._body
+        elif token == "/":
+            self.state = self._expecting_self_closing
+        elif isidentifier(token):
+            self.state = self._expecting_equal_sign
+        else:
+            return self.abort()
+
+    def _expecting_self_closing(self, token):
+        if token == ">":
+            self.stop()
+            return self.flush()
+        return self.abort()
+
+    def _expecting_equal_sign(self, token):
+        if token == '=':
+            self.state = self._expecting_value
+        else:
+            return self.abort()
+
+    def _expecting_value(self, token):
+        if token[0] in "'\"":
+            self.state = self._after_tag
+        elif token == "{":
+            self.brace_count = 1  # Start counting braces
+            self.state = self._jsx_expression
+            # Don't add the closing brace automatically
+            # self.cache.append("}")
+            self.sub_tokenizer = TSXTokenizer()
+            
+    def _jsx_expression(self, token):
+        # Handle nested braces in expressions
+        if token == "{":
+            self.brace_count += 1
+        elif token == "}":
+            self.brace_count -= 1
+            if self.brace_count == 0:
+                # We've found the matching closing brace
+                self.state = self._after_tag
+                return
+        
+        # Handle arrow functions in JSX attributes
+        if token == "=>":
+            self.arrow_function_detected = True
+            # Explicitly yield the arrow token to ensure it's processed
+            return ["=>"]
+        
+        # Handle type annotations in JSX attributes
+        if token == "<":
+            # This might be a TypeScript generic type annotation
+            # We'll continue in the current state and let the tokenizer handle it
+            pass
+
+    def _body(self, token):
+        if token == "<":
+            self.sub_tokenizer = XMLTagWithAttrTokenizer()
+            self.cache.pop()
+            return self.flush()
+
+        if token.startswith("</"):
+            self.stop()
+            return self.flush()
+
+        if token == '{':
+            self.sub_tokenizer = TSXTokenizer()
+            return self.flush()
+
+
+def isidentifier(token):
+    try:
+        return token.isidentifier()
+    except AttributeError:
+        return token.encode(encoding='UTF-8')[0].isalpha()

lizard-1.17.21/lizard_languages/perl.py

@@ -0,0 +1,103 @@
+'''
+Language parser for Perl
+'''
+
+from .code_reader import CodeReader, CodeStateMachine
+from .script_language import ScriptLanguageMixIn
+
+
+class PerlCommentsMixin(object):
+    @staticmethod
+    def get_comment_from_token(token):
+        if token.startswith('#'):
+            return token  # Return the entire comment including #
+        return None
+
+
+class PerlReader(CodeReader, ScriptLanguageMixIn):
+    # pylint: disable=R0903
+
+    ext = ['pl', 'pm']
+    language_names = ['perl']
+    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach', '&&', '||', '?', 'when'])
+
+    def __init__(self, context):
+        super(PerlReader, self).__init__(context)
+        self.parallel_states = [PerlStates(context)]
+
+    def preprocess(self, tokens):
+        comment = None
+        for token in tokens:
+            if comment is not None:
+                if token == '\n':
+                    yield comment
+                    comment = None
+                    yield token
+                else:
+                    comment += token
+            elif token == '#':
+                comment = token
+            else:
+                yield token
+        if comment is not None:
+            yield comment
+
+    def _state(self, token):
+        current_state = self.parallel_states[-1]
+        if token == '\n':
+            return
+        return current_state.state(token)
+
+    @staticmethod
+    def get_comment_from_token(token):
+        if token.startswith('#'):
+            # For forgiveness comments, return the entire comment
+            stripped = token.lstrip('#').strip()
+            if stripped.startswith('lizard forgives') or stripped.startswith('#lizard forgives'):
+                return '#lizard forgives'  # Return standardized forgiveness comment
+            return stripped  # Return the stripped comment for other cases
+        return None
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        return ScriptLanguageMixIn.generate_common_tokens(source_code, addition, token_class)
+
+
+class PerlStates(CodeStateMachine):
+    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach'])
+
+    def __init__(self, context):
+        super(PerlStates, self).__init__(context)
+        self.function_name = ''
+        self.brace_count = 0
+        self._state = self._state_global
+
+    def _state_global(self, token):
+        if token == 'sub':
+            self.function_name = ''
+            self.next(self._state_function_dec)
+        elif token == '{':
+            self.brace_count += 1
+        elif token == '}':
+            self.brace_count -= 1
+
+    def _state_function_dec(self, token):
+        if token == '{':
+            self.brace_count = 1
+            if self.function_name:
+                self.context.try_new_function(self.function_name)
+                self.context.confirm_new_function()
+            self.next(self._state_function_body)
+        elif token == ';':
+            self.next(self._state_global)
+        elif not token.isspace():
+            self.function_name = token
+
+    def _state_function_body(self, token):
+        if token == '{':
+            self.brace_count += 1
+        elif token == '}':
+            self.brace_count -= 1
+            if self.brace_count == 0:
+                self.context.end_of_function()
+                self.next(self._state_global) 

{lizard-1.17.19 → lizard-1.17.21}/lizard_languages/tsx.py

@@ -16,8 +16,19 @@ class TSXReader(TypeScriptReader, JSXMixin):
     @staticmethod
     @js_style_regex_expression
     def generate_tokens(source_code, addition='', token_class=None):
+        # Add support for TypeScript type annotations in JSX
+        addition = addition + \
+            r"|(?:<[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)*>)" + \
+            r"|(?:<\/[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z][A-Za-z0-9]*)*>)"
         return JSXMixin.generate_tokens(source_code, addition, token_class)
 
     def __init__(self, context):
         super(TSXReader, self).__init__(context)
         # No need for parallel states since JSX handling is in the mixin
+
+    def _expecting_func_opening_bracket(self, token):
+        # Handle TypeScript arrow functions with type annotations in JSX attributes
+        if token == ':':
+            self._consume_type_annotation()
+            return
+        super()._expecting_func_opening_bracket(token)

{lizard-1.17.19 → lizard-1.17.21}/lizard_languages/typescript.py

@@ -111,13 +111,13 @@ class TypeScriptTypeAnnotationStates(CodeStateMachine):
             self.next(self._state_simple_type, token)
 
     def _state_simple_type(self, token):
-        print(token)
         if token == '<':
-            print(token)
             self.next(self._state_generic_type, token)
         elif token in '{=;':
             self.saved_token = token
             self.statemachine_return()
+        elif token == '(':
+            self.next(self._function_type_annotation, token)
 
     @CodeStateMachine.read_inside_brackets_then("{}")
     def _inline_type_annotation(self, _):
@@ -126,3 +126,7 @@ class TypeScriptTypeAnnotationStates(CodeStateMachine):
     @CodeStateMachine.read_inside_brackets_then("<>")
     def _state_generic_type(self, token):
         self.statemachine_return()
+        
+    @CodeStateMachine.read_inside_brackets_then("()")
+    def _function_type_annotation(self, _):
+        self.statemachine_return()

lizard-1.17.19/lizard_languages/jsx.py

@@ -1,141 +0,0 @@
-'''
-Language parser for JSX
-'''
-
-from .javascript import JavaScriptReader
-from .typescript import JSTokenizer, Tokenizer
-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
-    @js_style_regex_expression
-    def generate_tokens(source_code, addition='', token_class=None):
-        addition = addition +\
-            r"|(?:\$\w+)" + \
-            r"|(?:\<\/\w+\>)" + \
-            r"|`.*?`"
-        js_tokenizer = TSXTokenizer()
-        for token in CodeReader.generate_tokens(
-                source_code, addition, token_class):
-            for tok in js_tokenizer(token):
-                yield tok
-
-    def _expecting_func_opening_bracket(self, token):
-        if token == '<':
-            self.next(self._expecting_jsx)
-            return
-        super()._expecting_func_opening_bracket(token)
-
-    def _expecting_jsx(self, token):
-        if token == '>':
-            self.next(self._expecting_func_opening_bracket)
-
-
-class JSXReader(JavaScriptReader, JSXMixin):
-    # pylint: disable=R0903
-
-    ext = ['jsx']
-    language_names = ['jsx']
-
-    @staticmethod
-    @js_style_regex_expression
-    def generate_tokens(source_code, addition='', token_class=None):
-        return JSXMixin.generate_tokens(source_code, addition, token_class)
-
-
-class XMLTagWithAttrTokenizer(Tokenizer):
-    def __init__(self):
-        super(XMLTagWithAttrTokenizer, self).__init__()
-        self.tag = None
-        self.state = self._global_state
-        self.cache = ['<']
-
-    def process_token(self, token):
-        self.cache.append(token)
-        if not token.isspace():
-            result = self.state(token)
-            if result is not None:
-                return result
-        return ()
-
-    def abort(self):
-        self.stop()
-        return self.cache
-
-    def flush(self):
-        tmp, self.cache = self.cache, []
-        return [''.join(tmp)]
-
-    def _global_state(self, token):
-        if not isidentifier(token):
-            return self.abort()
-        self.tag = token
-        self.state = self._after_tag
-
-    def _after_tag(self, token):
-        if token == '>':
-            self.state = self._body
-        elif token == "/":
-            self.state = self._expecting_self_closing
-        elif isidentifier(token):
-            self.state = self._expecting_equal_sign
-        else:
-            return self.abort()
-
-    def _expecting_self_closing(self, token):
-        if token == ">":
-            self.stop()
-            return self.flush()
-        return self.abort()
-
-    def _expecting_equal_sign(self, token):
-        if token == '=':
-            self.state = self._expecting_value
-        else:
-            return self.abort()
-
-    def _expecting_value(self, token):
-        if token[0] in "'\"":
-            self.state = self._after_tag
-        elif token == "{":
-            self.cache.append("}")
-            self.sub_tokenizer = TSXTokenizer()
-            self.state = self._after_tag
-
-    def _body(self, token):
-        if token == "<":
-            self.sub_tokenizer = XMLTagWithAttrTokenizer()
-            self.cache.pop()
-            return self.flush()
-
-        if token.startswith("</"):
-            self.stop()
-            return self.flush()
-
-        if token == '{':
-            self.sub_tokenizer = TSXTokenizer()
-            return self.flush()
-
-
-def isidentifier(token):
-    try:
-        return token.isidentifier()
-    except AttributeError:
-        return token.encode(encoding='UTF-8')[0].isalpha()