lizard 1.17.14__tar.gz → 1.17.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.14
+Version: 1.17.16
 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/
@@ -53,6 +53,7 @@ A list of supported languages:
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
 -  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -136,6 +137,13 @@ Exclude anything in the tests folder:
 
     lizard mySource/ -x"./tests/*"
 
+Use .gitignore file:
+
+::
+
+    lizard mySource/
+
+If there is a .gitignore file in the given path, lizard will automatically use it as an additional filter to exclude files that match the gitignore patterns. This is useful when you want to analyze only the tracked files in your git repository.
 
 Options
 ~~~~~~~

{lizard-1.17.14 → lizard-1.17.16}/README.rst

@@ -22,6 +22,7 @@ A list of supported languages:
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
 -  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -105,6 +106,13 @@ Exclude anything in the tests folder:
 
     lizard mySource/ -x"./tests/*"
 
+Use .gitignore file:
+
+::
+
+    lizard mySource/
+
+If there is a .gitignore file in the given path, lizard will automatically use it as an additional filter to exclude files that match the gitignore patterns. This is useful when you want to analyze only the tracked files in your git repository.
 
 Options
 ~~~~~~~

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.14
+Version: 1.17.16
 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/
@@ -53,6 +53,7 @@ A list of supported languages:
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
 -  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -136,6 +137,13 @@ Exclude anything in the tests folder:
 
     lizard mySource/ -x"./tests/*"
 
+Use .gitignore file:
+
+::
+
+    lizard mySource/
+
+If there is a .gitignore file in the given path, lizard will automatically use it as an additional filter to exclude files that match the gitignore patterns. This is useful when you want to analyze only the tracked files in your git repository.
 
 Options
 ~~~~~~~

{lizard-1.17.14 → lizard-1.17.16}/lizard.egg-info/SOURCES.txt

@@ -67,6 +67,7 @@ lizard_languages/tnsdl.py
 lizard_languages/tsx.py
 lizard_languages/ttcn.py
 lizard_languages/typescript.py
+lizard_languages/vue.py
 lizard_languages/zig.py
 test/testApplication.py
 test/testAssertionExtension.py

{lizard-1.17.14 → lizard-1.17.16}/lizard.egg-info/requires.txt

@@ -1 +1,2 @@
 pygments
+pathspec

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

@@ -298,8 +298,7 @@ class FunctionInfo(Nesting):  # pylint: disable=R0902
         return self.name.split('::')[-1]
 
     location = property(lambda self:
-                        " %(name)s@%(start_line)s-%(end_line)s@%(filename)s"
-                        % self.__dict__)
+                        f" {self.name}@{self.start_line}-{self.end_line}@{self.filename}")
 
     parameter_count = property(lambda self: len(self.parameters))
 
@@ -723,17 +722,13 @@ class OutputScheme(object):
             if e.get("avg_caption", None)])
 
     def clang_warning_format(self):
-        return (
-            "{f.filename}:{f.start_line}: warning: {f.name} has " +
-            ", ".join([
-                "{{f.{ext[value]}}} {caption}"
-                .format(ext=e, caption=e['caption'].strip())
-                for e in self.items[:-1]
-                ]))
+        return ("{f.filename}:{f.start_line}: warning: {f.name} has {f.nloc} NLOC, "
+                "{f.cyclomatic_complexity} CCN, {f.token_count} token, {f.parameter_count} PARAM, "
+                "{f.length} length, {f.max_nesting_depth} ND")
 
     def msvs_warning_format(self):
         return (
-            "{f.filename}({f.start_line}): warning: {f.name} has " +
+            "{f.filename}({f.start_line}): warning: {f.name} ({f.long_name}) has " +
             ", ".join([
                 "{{f.{ext[value]}}} {caption}"
                 .format(ext=e, caption=e['caption'].strip())
@@ -901,14 +896,43 @@ def md5_hash_file(full_path_name):
 def get_all_source_files(paths, exclude_patterns, lans):
     '''
     Function counts md5 hash for the given file and checks if it isn't a
-    duplicate using set of hashes for previous files '''
+    duplicate using set of hashes for previous files.
+    
+    If a .gitignore file is found in any of the given paths, it will be used
+    to filter out files that match the gitignore patterns.
+    '''
     hash_set = set()
+    gitignore_spec = None
+    base_path = None
+
+    def _load_gitignore():
+        nonlocal gitignore_spec, base_path
+        try:
+            import pathspec
+            for path in paths:
+                gitignore_path = os.path.join(path, '.gitignore')
+                if os.path.exists(gitignore_path):
+                    with open(gitignore_path, 'r') as gitignore_file:
+                        # Read lines and strip whitespace and empty lines
+                        patterns = [line.strip() for line in gitignore_file.readlines()]
+                        patterns = [p for p in patterns if p and not p.startswith('#')]
+                        gitignore_spec = pathspec.PathSpec.from_lines('gitwildmatch', patterns)
+                        base_path = path
+                    break
+        except ImportError:
+            pass
 
     def _support(reader):
         return not lans or set(lans).intersection(
             reader.language_names)
 
     def _validate_file(pathname):
+        if gitignore_spec is not None and base_path is not None:
+            rel_path = os.path.relpath(pathname, base_path)
+            # Normalize path separators for consistent matching
+            rel_path = rel_path.replace(os.sep, '/')
+            if gitignore_spec.match_file(rel_path):
+                return False
         return (
             pathname in paths or (
                 get_reader_for(pathname) and
@@ -931,6 +955,7 @@ def get_all_source_files(paths, exclude_patterns, lans):
                     for filename in files:
                         yield os.path.join(root, filename)
 
+    _load_gitignore()
     return filter(_validate_file, all_listed_files(paths))
 
 
@@ -972,7 +997,7 @@ def parse_args(argv):
         if inferred_printer:
             if not opt.printer:
                 opt.printer = inferred_printer
-            else:
+            elif opt.printer != inferred_printer:
                 msg = "Warning: overriding output file extension.\n"
                 sys.stderr.write(msg)
     return opt

{lizard-1.17.14 → lizard-1.17.16}/lizard_ext/csvoutput.py

@@ -36,9 +36,9 @@ def csv_output(result, options):
     if options.verbose:
         extension_caption = ""
         for caption in extension_captions:
-            extension_caption = "{},{}".format(extension_caption, caption)
-        print("NLOC,CCN,token,PARAM,length,location,file,function," +
-              "long_name,start,end{}".format(extension_caption))
+            extension_caption = f"{extension_caption},{caption}"
+        print(f"NLOC,CCN,token,PARAM,length,location,file,function," +
+              f"long_name,start,end{extension_caption}")
 
     for source_file in result:
         if source_file:
@@ -46,25 +46,11 @@ def csv_output(result, options):
                 if source_function:
                     extension_string = ''
                     for variable in extension_variables:
-                        extension_string = '{},{}'.\
-                            format(extension_string,
-                                   source_function.__getattribute__(variable))
-                    print('{},{},{},{},{},"{}","{}","{}","{}",{},{}{}'.format(
-                        source_function.nloc,
-                        source_function.cyclomatic_complexity,
-                        source_function.token_count,
-                        len(source_function.parameters),
-                        source_function.length,
-                        "{}@{}-{}@{}".format(
-                            source_function.name.replace("\"", "'"),
-                            source_function.start_line,
-                            source_function.end_line,
-                            source_file.filename
-                        ),
-                        source_file.filename,
-                        source_function.name.replace("\"", "'"),
-                        source_function.long_name.replace("\"", "'"),
-                        source_function.start_line,
-                        source_function.end_line,
-                        extension_string
-                    ))
+                        extension_string = f"{extension_string},{source_function.__getattribute__(variable)}"
+                    print(f"{source_function.nloc},{source_function.cyclomatic_complexity},"
+                          f"{source_function.token_count},{len(source_function.parameters)},"
+                          f'{source_function.length},"{source_function.name.replace(chr(34), chr(39))}@'
+                          f'{source_function.start_line}-{source_function.end_line}@{source_file.filename}",'
+                          f'"{source_file.filename}","{source_function.name.replace(chr(34), chr(39))}",'
+                          f'"{source_function.long_name.replace(chr(34), chr(39))}",'
+                          f"{source_function.start_line},{source_function.end_line}{extension_string}")

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

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

{lizard-1.17.14 → lizard-1.17.16}/lizard_languages/__init__.py

@@ -23,6 +23,7 @@ from .fortran import FortranReader
 from .solidity import SolidityReader
 from .jsx import JSXReader
 from .tsx import TSXReader
+from .vue import VueReader
 
 
 def languages():
@@ -50,6 +51,7 @@ def languages():
         ZigReader,
         JSXReader,
         TSXReader,
+        VueReader,
     ]
 
 

{lizard-1.17.14 → lizard-1.17.16}/lizard_languages/code_reader.py

@@ -8,7 +8,7 @@ from functools import reduce
 from operator import or_
 
 
-class CodeStateMachine(object):
+class CodeStateMachine:
     """ the state machine """
     # pylint: disable=R0903
     # pylint: disable=R0902
@@ -50,6 +50,7 @@ class CodeStateMachine(object):
             self.next(self.saved_state)
             if self.callback:
                 self.callback()
+                self.callback = None
         self.last_token = token
         if self.to_exit:
             return True

lizard-1.17.16/lizard_languages/csharp.py

@@ -0,0 +1,62 @@
+'''
+Language parser for C Sharp
+'''
+
+from .clike import CLikeReader, CLikeStates, CLikeNestingStackStates
+
+
+class CSharpReader(CLikeReader):
+    # pylint: disable=R0903
+
+    ext = ['cs']
+    language_names = ['csharp']
+
+    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
+                      'case', '??'])
+
+    def __init__(self, context):
+        super(CSharpReader, self).__init__(context)
+        self.parallel_states = [
+            CSharpStates(context),
+            CLikeNestingStackStates(context)
+        ]
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        return CLikeReader.generate_tokens(
+                source_code, r"|(?:\?\?)", token_class)
+
+
+class CSharpStates(CLikeStates):
+    def __init__(self, context):
+        super(CSharpStates, self).__init__(context)
+        self.in_primary_constructor = False
+        self.class_name = None
+
+    def try_new_function(self, name):
+        if not self.in_primary_constructor:
+            super(CSharpStates, self).try_new_function(name)
+            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 in ("class", "struct", "record"):
+            self.class_name = None
+            self._state = self._state_class_declaration
+        else:
+            super(CSharpStates, self)._state_global(token)
+
+    def _state_class_declaration(self, token):
+        if token == '(':  # Primary constructor
+            self.in_primary_constructor = True
+            self._state = self._state_primary_constructor
+        elif token == '{':
+            self._state = self._state_global
+        elif token[0].isalpha():
+            if not self.class_name:  # Only set class name if not already set
+                self.class_name = token
+
+    @CLikeStates.read_inside_brackets_then("()", "_state_class_declaration")
+    def _state_primary_constructor(self, _):
+        """Skip primary constructor parameters without counting them as a function"""
+        self.in_primary_constructor = False

lizard-1.17.16/lizard_languages/java.py

@@ -0,0 +1,89 @@
+'''
+Language parser for Java
+'''
+
+from .clike import CLikeReader, CLikeStates, CLikeNestingStackStates
+
+
+class JavaReader(CLikeReader):
+    # pylint: disable=R0903
+
+    ext = ['java']
+    language_names = ['java']
+
+    def __init__(self, context):
+        super(JavaReader, self).__init__(context)
+        self.parallel_states = [
+                JavaStates(context),
+                CLikeNestingStackStates(context)]
+
+
+class JavaStates(CLikeStates):  # pylint: disable=R0903
+    def __init__(self, context):
+        super(JavaStates, self).__init__(context)
+        self.class_name = None
+        self.is_record = False
+        self.in_record_constructor = False
+
+    def _state_old_c_params(self, token):
+        if token == '{':
+            self._state_dec_to_imp(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:
+            self.in_record_constructor = True
+            self._state = self._state_record_compact_constructor
+            return
+        self.context.try_new_function(name)
+        self._state = self._state_function
+        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
+        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
+        if not self.in_record_constructor:  # Only process as potential function if not in record constructor
+            super(JavaStates, self)._state_global(token)
+
+    def _state_decorator(self, _):
+        self._state = self._state_post_decorator
+
+    def _state_post_decorator(self, token):
+        if token == '.':
+            self._state = self._state_decorator
+        else:
+            self._state = self._state_global
+            self._state(token)
+
+    def _state_class_declaration(self, token):
+        if token == '{':
+            self._state = self._state_global
+        elif token == '(':  # Record parameters
+            self._state = self._state_record_parameters
+        elif token[0].isalpha():
+            if not self.class_name:  # Only set class name if not already set
+                self.class_name = token
+
+    def _state_record_parameters(self, token):
+        if token == ')':
+            self._state = self._state_class_declaration
+
+    def _state_record_compact_constructor(self, token):
+        if token == '{':
+            self._state = self._state_record_constructor_body
+            return
+        self._state = self._state_global
+        self._state(token)
+
+    def _state_record_constructor_body(self, token):
+        if token == '}':
+            self.in_record_constructor = False
+            self._state = self._state_global

lizard-1.17.16/lizard_languages/javascript.py

@@ -0,0 +1,19 @@
+'''
+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)

{lizard-1.17.14 → lizard-1.17.16}/lizard_languages/js_style_language_states.py

@@ -11,8 +11,18 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
         self.last_tokens = ''
         self.function_name = ''
         self.started_function = None
+        self.as_object = False
 
     def _state_global(self, token):
+        if self.as_object:
+            if token == ':':
+                self.function_name = self.last_tokens
+                return
+            elif token == '(':
+                self._function(self.last_tokens)
+                self.next(self._function, token)
+                return
+
         if token in '.':
             self._state = self._field
             self.last_tokens += token
@@ -29,11 +39,11 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
             self.function_name = self.last_tokens
         elif token == "(":
             self.sub_state(
-                JavaScriptStyleLanguageStates(self.context))
+                self.__class__(self.context))
         elif token in '{':
             if self.started_function:
                 self.sub_state(
-                    JavaScriptStyleLanguageStates(self.context),
+                    self.__class__(self.context),
                     self._pop_function_from_stack)
             else:
                 self.read_object()
@@ -46,7 +56,12 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
         self.last_tokens = token
 
     def read_object(self):
-        self.sub_state(ES6ObjectStates(self.context))
+        def callback():
+            self.next(self._state_global)
+
+        object_reader = self.__class__(self.context)
+        object_reader.as_object = True
+        self.sub_state(object_reader, callback)
 
     def statemachine_before_return(self):
         self._pop_function_from_stack()
@@ -63,16 +78,14 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
             return
 
         self.sub_state(
-            JavaScriptStyleLanguageStates(self.context),
-            callback)
+            self.__class__(self.context), callback)
 
     def _expecting_statement_or_block(self, token):
         def callback():
             self.next(self._state_global)
         if token == "{":
             self.sub_state(
-                JavaScriptStyleLanguageStates(self.context),
-                callback)
+                self.__class__(self.context), callback)
         else:
             self.next(self._state_global, token)
 
@@ -116,17 +129,3 @@ class JavaScriptStyleLanguageStates(CodeStateMachine):  # pylint: disable=R0903
         if token != '{':
             self.started_function = None
         self.next(self._state_global, token)
-
-
-class ES6ObjectStates(JavaScriptStyleLanguageStates):  # pylint: disable=R0903
-    def __init__(self, context):
-        super(ES6ObjectStates, self).__init__(context)
-
-    def _state_global(self, token):
-        if token == ':':
-            self.function_name = self.last_tokens
-        elif token == '(':
-            self._function(self.last_tokens)
-            self.next(self._function, token)
-        else:
-            super(ES6ObjectStates, self)._state_global(token)

lizard-1.17.16/lizard_languages/js_style_regex_expression.py

@@ -0,0 +1,53 @@
+'''
+generate token with javascript style regular expression.
+'''
+
+import re
+
+
+def js_style_regex_expression(func):
+    def generate_tokens_with_regex(source_code, addition='', token_class=None):
+        regx_regx = r"\/(\S*?[^\s\\]\/)+?(igm)*"
+        regx_pattern = re.compile(regx_regx)
+        tokens = list(func(source_code, addition, token_class))
+        result = []
+        i = 0
+        while i < len(tokens):
+            token = tokens[i]
+            if token == '/':
+                # Check if this could be a regex pattern
+                is_regex = False
+                if i == 0:
+                    is_regex = True
+                elif i > 0:
+                    prev_token = tokens[i-1].strip()
+                    if prev_token and prev_token[-1] in '=,({[?:!&|;':
+                        is_regex = True
+
+                if is_regex:
+                    # This is likely a regex pattern start
+                    regex_tokens = [token]
+                    i += 1
+                    while i < len(tokens) and not tokens[i].endswith('/'):
+                        regex_tokens.append(tokens[i])
+                        i += 1
+                    if i < len(tokens):
+                        regex_tokens.append(tokens[i])
+                        i += 1
+                        # Check for regex flags
+                        if i < len(tokens) and re.match(r'^[igm]+$', tokens[i]):
+                            regex_tokens.append(tokens[i])
+                            i += 1
+                    combined = ''.join(regex_tokens)
+                    if regx_pattern.match(combined):
+                        result.append(combined)
+                    else:
+                        result.extend(regex_tokens)
+                else:
+                    # This is a division operator
+                    result.append(token)
+            else:
+                result.append(token)
+            i += 1
+        return result
+    return generate_tokens_with_regex