lizard 1.17.19__py2.py3-none-any.whl → 1.17.21__py2.py3-none-any.whl

{lizard-1.17.19.dist-info → lizard-1.17.21.dist-info}/METADATA

@@ -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/
@@ -72,6 +72,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.dist-info → lizard-1.17.21.dist-info}/RECORD

@@ -25,9 +25,9 @@ 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=oguHTKBWAqPz-fmtCOkqHzNbUNECBfUhm0EIg6y01RI,182
+lizard_ext/version.py,sha256=3mpAZCQFxtZ-yEx47ZY238MZafb6rPxy9lZff5hymyA,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=2mvrPWMJVCq981kMjoAPEi2O07C8vo-vUWOG_wp7vKQ,1473
+lizard_languages/__init__.py,sha256=ArNmUrVSU6HFxhDka1-vWMZpVIM39P-gqv6BoOLNMV8,1522
 lizard_languages/clike.py,sha256=INd5tkvwEVZm7dx2yHG2OIFHZn7JzQGmnT9WQNFZ2XU,11110
 lizard_languages/code_reader.py,sha256=P0PkE4QZBWOEj6cFHA4hj3hcLZLcGnqH31EmtltxlaE,6240
 lizard_languages/csharp.py,sha256=EfFAIOIcJXUUhXTlZApXGSlzG34NZvHM9OSe6m7hpv0,2141
@@ -36,14 +36,15 @@ lizard_languages/fortran.py,sha256=KATDsnfjob5W3579A_VxbwrbTkK7Rx3p0eXdBgjx25I,8
 lizard_languages/gdscript.py,sha256=KwlGoODilQnFgXvODpq_XlA6fV3hGbN9fd7bsiEUn78,637
 lizard_languages/go.py,sha256=iU2wZ0Iuo4OifscZhoHS_jDbdGYxquocqmvYX0l9MnE,1358
 lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
-lizard_languages/java.py,sha256=J8FYdgzGK5ojmfxSfMfWopKGTLsHwJ123XOOZCfi51c,4957
+lizard_languages/java.py,sha256=c1rd0PN4iIrYHPLTFW67YsBX6pizsrJma3tfCDj9B2Q,4936
 lizard_languages/javascript.py,sha256=qqxocZbZ6ivchhswRBBSjEJKiTClnm9ScOy4nlX4JKA,318
-lizard_languages/js_style_language_states.py,sha256=Ie0eA15rd0gfahdNzUlSkQa-o_j5idTIB82JU32c378,4165
+lizard_languages/js_style_language_states.py,sha256=AdiehzSziZIbuWMomYmchNsJr7ZqtxN6l29osj3SA3A,4431
 lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
-lizard_languages/jsx.py,sha256=KA9tDZ8kRSey8RefeC6DJg36yLBi6AEbm5JmVB-TQMU,3951
+lizard_languages/jsx.py,sha256=DMagQSEvXZwy9AUj8B2l39PqgcAoZntAmEm67IKF7iM,8890
 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/perl.py,sha256=bSBolem2X6TjINz7pJGO_WhQxc-pAeiun0Q3RDeUOkY,3367
 lizard_languages/php.py,sha256=8OufyR2TIWyf3bXuTmp37Vwf_tEPF4YV5M3i5_jnguA,1377
 lizard_languages/python.py,sha256=1e0dKbl82z-i_5dswkKaFIV5WuQDKztPHh9UNmSTLyE,3848
 lizard_languages/ruby.py,sha256=HL1ZckeuUUJU3QSVAOPsG_Zsl0C6X2PX5_VaWqclzkM,2277
@@ -54,14 +55,14 @@ lizard_languages/script_language.py,sha256=UUO3Wjkoa-ZqwwvcwvhOr5tg1rVavcrEYx3dN
 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/tsx.py,sha256=pzScdziLmFkD1c0LfwUNyC64C0HFmqt16QtsANu0UJ8,639
+lizard_languages/tsx.py,sha256=4fhi3sUnvjU4XfGaFUEGOdAYOx6ThGpIMOIS9VSL6cQ,1160
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=jXN3q01g46tWVb9jXjsmwypcAXx0t-vpK3UFQ-SHw9U,3645
+lizard_languages/typescript.py,sha256=P_rphg5AXJAk9QetmvVKc2911ilPmiRa0Qa5fHWleJg,3829
 lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
 lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
-lizard-1.17.19.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.19.dist-info/METADATA,sha256=yX7xfYELh1ZHKXiGt2mNF9ABjGhiU6SDph-3nvuODZU,15745
-lizard-1.17.19.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.17.19.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
-lizard-1.17.19.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.19.dist-info/RECORD,,
+lizard-1.17.21.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.21.dist-info/METADATA,sha256=JSVKupJ-s_F1BqRK88FS30969tOc9TaHxPaPlZzXdzo,15753
+lizard-1.17.21.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.21.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.21.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.21.dist-info/RECORD,,

lizard_ext/version.py

@@ -3,4 +3,4 @@
 #
 # pylint: disable=missing-docstring,invalid-name
 
-version = "1.17.19"
+version = "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_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_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_languages/jsx.py

@@ -6,6 +6,7 @@ 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):
@@ -17,6 +18,11 @@ class TSXTokenizer(JSTokenizer):
             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
@@ -30,6 +36,7 @@ class JSXMixin:
         addition = addition +\
             r"|(?:\$\w+)" + \
             r"|(?:\<\/\w+\>)" + \
+            r"|(?:=>)" + \
             r"|`.*?`"
         js_tokenizer = TSXTokenizer()
         for token in CodeReader.generate_tokens(
@@ -41,13 +48,94 @@ class JSXMixin:
         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
 
@@ -57,8 +145,17 @@ class JSXReader(JavaScriptReader, JSXMixin):
     @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):
@@ -66,6 +163,8 @@ class XMLTagWithAttrTokenizer(Tokenizer):
         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)
@@ -115,9 +214,34 @@ class XMLTagWithAttrTokenizer(Tokenizer):
         if token[0] in "'\"":
             self.state = self._after_tag
         elif token == "{":
-            self.cache.append("}")
+            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()
-            self.state = self._after_tag
+            
+    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 == "<":

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_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_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()