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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.21
+Version: 1.17.23
 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.21.dist-info → lizard-1.17.23.dist-info}/RECORD

@@ -25,7 +25,7 @@ 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=3mpAZCQFxtZ-yEx47ZY238MZafb6rPxy9lZff5hymyA,182
+lizard_ext/version.py,sha256=8OYSScMy6WgCedG7UcZmt7GxKDmCpya3NUQHG12M8_w,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
 lizard_languages/__init__.py,sha256=ArNmUrVSU6HFxhDka1-vWMZpVIM39P-gqv6BoOLNMV8,1522
 lizard_languages/clike.py,sha256=INd5tkvwEVZm7dx2yHG2OIFHZn7JzQGmnT9WQNFZ2XU,11110
@@ -44,7 +44,7 @@ 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/perl.py,sha256=WUHuO9lIBRpL0fJKpAtEVsEatGMqzY2WymF8kSdPGRs,12143
 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
@@ -60,9 +60,9 @@ lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
 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.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-1.17.23.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.23.dist-info/METADATA,sha256=RSP5Eq3wzytjP5T8yFmfWZaDaI9Xkd5iFCRg65yeGtE,15753
+lizard-1.17.23.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.23.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.23.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.23.dist-info/RECORD,,

lizard_ext/version.py

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

lizard_languages/perl.py

@@ -19,7 +19,7 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
     ext = ['pl', 'pm']
     language_names = ['perl']
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach', '&&', '||', '?', 'when'])
+    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach', '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
 
     def __init__(self, context):
         super(PerlReader, self).__init__(context)
@@ -64,34 +64,157 @@ class PerlReader(CodeReader, ScriptLanguageMixIn):
 
 
 class PerlStates(CodeStateMachine):
-    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach'])
+    _conditions = set(['if', 'elsif', 'unless', 'while', 'until', 'for', 'foreach', '&&', '||', '?', ':', 'when', 'given', 'default', 'do'])
 
     def __init__(self, context):
         super(PerlStates, self).__init__(context)
         self.function_name = ''
+        self.package_name = ''
+        self.variable_name = ''
         self.brace_count = 0
+        self.paren_count = 0
+        self.in_attribute = False
+        self.anonymous_count = 0
         self._state = self._state_global
 
     def _state_global(self, token):
-        if token == 'sub':
+        if token == 'package':
+            self.next(self._state_package_dec)
+        elif token == 'sub':
             self.function_name = ''
             self.next(self._state_function_dec)
         elif token == '{':
             self.brace_count += 1
         elif token == '}':
             self.brace_count -= 1
+        elif token == '(':
+            self.paren_count += 1
+            self.next(self._state_function_call)
+        elif token == '$' or token == 'my' or token == 'our' or token == 'local':
+            self.variable_name = ''
+            self.next(self._state_variable)
+
+    def _state_package_dec(self, token):
+        if not token.isspace():
+            self.package_name = token
+            self.next(self._state_global)
+
+    def _state_variable(self, token):
+        if token == '$':
+            # Skip the $ in variable names
+            pass
+        elif token == '=':
+            self.next(self._state_assignment)
+        elif token == ';':
+            self.variable_name = ''
+            self.next(self._state_global)
+        elif not token.isspace() and self.variable_name == '':
+            self.variable_name = token
+
+    def _state_assignment(self, token):
+        if token == 'sub':
+            self.next(self._state_anon_sub)
+        elif token == ';':
+            self.variable_name = ''
+            self.next(self._state_global)
+
+    def _state_function_call(self, token):
+        if token == 'sub':
+            # Inline anonymous subroutine as argument
+            self.anonymous_count += 1
+            full_name = f"<anonymous>"
+            if self.package_name:
+                full_name = f"{self.package_name}::{full_name}"
+            
+            self.context.try_new_function(full_name)
+            self.context.confirm_new_function()
+            self.next(self._state_anon_brace_search)
+        elif token == ')':
+            self.paren_count -= 1
+            if self.paren_count == 0:
+                self.next(self._state_global)
+        elif token == '(':
+            self.paren_count += 1
+
+    def _state_anon_sub(self, token):
+        if token == '{':
+            self.brace_count = 1
+            full_name = '<anonymous>'
+            # Use variable name if available for more readable function names
+            if self.variable_name:
+                full_name = '$' + self.variable_name
+            
+            if self.package_name:
+                full_name = f"{self.package_name}::{full_name}"
+            
+            self.context.try_new_function(full_name)
+            self.context.confirm_new_function()
+            self.next(self._state_function_body)
 
     def _state_function_dec(self, token):
         if token == '{':
             self.brace_count = 1
             if self.function_name:
-                self.context.try_new_function(self.function_name)
+                full_name = self.function_name
+                if self.package_name:
+                    full_name = f"{self.package_name}::{self.function_name}"
+                self.context.try_new_function(full_name)
                 self.context.confirm_new_function()
             self.next(self._state_function_body)
+        elif token == ':':
+            self.in_attribute = True
         elif token == ';':
+            # Forward declaration like "sub func_name;"
+            if self.function_name:
+                full_name = self.function_name
+                if self.package_name:
+                    full_name = f"{self.package_name}::{self.function_name}"
+                self.context.try_new_function(full_name)
+                self.context.confirm_new_function()
+                # Empty function body
+                self.context.end_of_function()
             self.next(self._state_global)
+        elif token == '(':
+            # Function with parameter prototype like "sub fetch($)"
+            # Save the current function name and look for closing paren
+            self.paren_count = 1
+            self.next(self._state_function_prototype)
+        elif token == 'sub':
+            # Handle anonymous subroutine like 'callback(sub { ... })'
+            self.anonymous_count += 1
+            full_name = f"<anonymous>"
+            if self.package_name:
+                full_name = f"{self.package_name}::{full_name}"
+            self.context.try_new_function(full_name)
+            self.context.confirm_new_function()
+            self.next(self._state_anon_brace_search)
         elif not token.isspace():
-            self.function_name = token
+            if not self.in_attribute:
+                self.function_name = token
+            else:
+                # Skip attribute name
+                self.in_attribute = False
+
+    def _state_function_prototype(self, token):
+        # Handle parameter prototypes after function name: sub fetch($) { ... }
+        if token == ')':
+            self.paren_count -= 1
+            if self.paren_count == 0:
+                # Return to function declaration state to handle the opening brace
+                self.next(self._state_function_dec)
+        elif token == '(':
+            self.paren_count += 1
+
+    def _state_anon_brace_search(self, token):
+        if token == '{':
+            self.brace_count = 1
+            self.next(self._state_function_body)
+        elif token == '(':
+            self.paren_count += 1
+        elif token == ')':
+            self.paren_count -= 1
+            if self.paren_count == 0:
+                self.next(self._state_global)
 
     def _state_function_body(self, token):
         if token == '{':
@@ -100,4 +223,108 @@ class PerlStates(CodeStateMachine):
             self.brace_count -= 1
             if self.brace_count == 0:
                 self.context.end_of_function()
-                self.next(self._state_global) 
+                self.next(self._state_global)
+        elif token == '?':
+            # Ternary operator increases complexity
+            self.context.add_condition()
+        elif token == ':':
+            # Colon part of ternary operator also increases complexity
+            self.context.add_condition()
+        elif token == 'sub':
+            # Check if it's a nested named subroutine or anonymous
+            self.next(self._state_nested_sub_dec)
+        elif token == '(':
+            # Track function calls inside function body
+            self.paren_count += 1
+            self.next(self._state_nested_call)
+
+    def _state_nested_sub_dec(self, token):
+        if token.isspace():
+            return
+        elif token == '{':
+            # Anonymous sub
+            self.brace_count += 1
+            self.anonymous_count += 1
+            anon_name = f"<anonymous>"
+            if self.package_name:
+                anon_name = f"{self.package_name}::{anon_name}"
+            self.context.add_condition()  # Count sub as a condition
+            self.next(self._state_function_body)
+        else:
+            # Named nested sub
+            nested_func_name = token
+            full_name = nested_func_name
+            if self.package_name:
+                full_name = f"{self.package_name}::{nested_func_name}"
+            
+            # Save current function state
+            saved_func_context = self.context
+            
+            # Create a new function for the nested sub
+            self.context.try_new_function(full_name)
+            self.context.confirm_new_function()
+            self.next(self._state_nested_named_sub_brace_search)
+
+    def _state_nested_named_sub_brace_search(self, token):
+        if token == '{':
+            self.brace_count = 1
+            self.next(self._state_nested_sub_body)
+        elif token.isspace():
+            return
+        elif token == ':':
+            # Handle attributes in nested sub
+            self.in_attribute = True
+            return
+        elif token == ';':
+            # Forward declaration
+            self.context.end_of_function()
+            self.next(self._state_function_body)
+
+    def _state_nested_sub_body(self, token):
+        if token == '{':
+            self.brace_count += 1
+        elif token == '}':
+            self.brace_count -= 1
+            if self.brace_count == 0:
+                # End the nested function
+                self.context.end_of_function()
+                # Return to parent function
+                self.next(self._state_function_body)
+
+    def _state_nested_call(self, token):
+        if token == 'sub':
+            # Inline anonymous subroutine as argument
+            self.anonymous_count += 1
+            full_name = f"<anonymous>"
+            if self.package_name:
+                full_name = f"{self.package_name}::{full_name}"
+            
+            self.context.try_new_function(full_name)
+            self.context.confirm_new_function()
+            self.next(self._state_nested_anon_search)
+        elif token == ')':
+            self.paren_count -= 1
+            if self.paren_count == 0:
+                self.next(self._state_function_body)
+        elif token == '(':
+            self.paren_count += 1
+
+    def _state_nested_anon_search(self, token):
+        if token == '{':
+            self.brace_count += 1
+            self.next(self._state_nested_anon_body)
+        elif token == '(':
+            self.paren_count += 1
+        elif token == ')':
+            self.paren_count -= 1
+            if self.paren_count == 0:
+                self.next(self._state_function_body)
+
+    def _state_nested_anon_body(self, token):
+        if token == '{':
+            self.brace_count += 1
+        elif token == '}':
+            self.brace_count -= 1
+            if self.brace_count == 1:  # Back to outer function level
+                self.context.end_of_function()
+                self.next(self._state_function_body)