lizard 1.17.18__py2.py3-none-any.whl → 1.17.20__py2.py3-none-any.whl

{lizard-1.17.18.dist-info → lizard-1.17.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.18
+Version: 1.17.20
 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.18.dist-info → lizard-1.17.20.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=uWQn4tywlvI23SaJS5RkBAVDfoz8Vw2OgpU5tNOMZXc,182
+lizard_ext/version.py,sha256=IB2eWTQRCnG9RBY141iHFEvno0xjjBabRujvFSaRAfg,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
 lizard_languages/__init__.py,sha256=2mvrPWMJVCq981kMjoAPEi2O07C8vo-vUWOG_wp7vKQ,1473
 lizard_languages/clike.py,sha256=INd5tkvwEVZm7dx2yHG2OIFHZn7JzQGmnT9WQNFZ2XU,11110
@@ -36,11 +36,11 @@ 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=O-RAQIFCFJ2VnlpF2sE5xave8n56bnuZl32AZZ42oDs,4929
+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
@@ -54,14 +54,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.18.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.18.dist-info/METADATA,sha256=RQB8p4hjr5Iap0Bbx1upXmyGAiW3MZiuyrQ_QUCuhn0,15745
-lizard-1.17.18.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.17.18.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
-lizard-1.17.18.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.18.dist-info/RECORD,,
+lizard-1.17.20.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.20.dist-info/METADATA,sha256=RPB3J8UEOaOw7SP0BNMOf7JiU_sXiF0eXiVrYdCiwFA,15745
+lizard-1.17.20.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.20.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.20.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.20.dist-info/RECORD,,

lizard_ext/version.py

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

lizard_languages/java.py

@@ -128,7 +128,7 @@ class JavaFunctionBodyStates(JavaStates):
                 self.next(self._state_global)
             self.sub_state(JavaClassBodyStates("(anonymous)", False, self.context), callback, token)
             return
-        self.next(self._state_global)
+        self.next(self._state_global, token)
 
 class JavaClassBodyStates(JavaStates):
     def __init__(self, class_name, is_record, context):

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