lizard 1.17.14__py2.py3-none-any.whl → 1.17.16__py2.py3-none-any.whl

{lizard-1.17.14.dist-info → lizard-1.17.16.dist-info}/METADATA

@@ -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/
@@ -29,6 +29,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 License-File: LICENSE.txt
 Requires-Dist: pygments
+Requires-Dist: pathspec
 
 |Web Site| Lizard
 =================
@@ -54,6 +55,7 @@ A list of supported languages:
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
 -  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -137,6 +139,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.dist-info → lizard-1.17.16.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lizard.py,sha256=WfzR6yEkclgbV2CTpDZrwWDnmNUnXyd6BIL6LR--QWk,38609
+lizard.py,sha256=m-wnNDtLaug8yvK65Ex1IMRTubo6uFQAfdcdRN9x5Mg,39927
 lizard_ext/__init__.py,sha256=Cz0pvH6QHyadK-rAeeEhQVsm0hW5M-fBQgV4FBaX9zk,500
 lizard_ext/auto_open.py,sha256=byD_RbeVhvSUhR2bJMRitvA3zcKEapFwv0-XaDJ6GFo,1096
-lizard_ext/csvoutput.py,sha256=IGTGICiK_IJcldRGDhd_jNDohxFWJEWYOVxkemaY20Q,3051
+lizard_ext/csvoutput.py,sha256=43fhmo8kB85qcdujCwySGNuTC4FkKUPLqIApPeljPnA,2663
 lizard_ext/default_ordered_dict.py,sha256=YbVz6nPlQ6DjWc_EOFBz6AJN2XLo9dpnUdeyejQvUDE,831
 lizard_ext/extension_base.py,sha256=rnjUL2mqSGToUVYydju7fa8ZwynLPY8S1F17gIJP55I,346
 lizard_ext/htmloutput.py,sha256=oavhEzCIJtoJrFveiWIp0pMAOwg4pukJ6l07IpmPiag,4426
@@ -25,22 +25,22 @@ 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=Q_IWUX-GJQsIg-nJXStY9pJaspkNNkBE5mLUB-v3UKw,182
+lizard_ext/version.py,sha256=s8Ej-6FrgTUH06Kp-lskbDvVReimxGKBZNzim7QUtbI,182
 lizard_ext/xmloutput.py,sha256=-cbh0he4O_X-wX56gkv9AnSPNN0qvR7FACqlBeezUS4,5609
-lizard_languages/__init__.py,sha256=PsUTjwesQ_Kk2SLsaI2Sn7ePtWLEQs2XW6EOPJJybcA,1427
+lizard_languages/__init__.py,sha256=2mvrPWMJVCq981kMjoAPEi2O07C8vo-vUWOG_wp7vKQ,1473
 lizard_languages/clike.py,sha256=Lnwkma-jEu8FNVEPqTAKPkz1Hi0T_dP7H9Jyq0Bd0kQ,10725
-lizard_languages/code_reader.py,sha256=sMkHfIjZTom3d5gINfm42vUY28kTOOdxEUboc7eRMUU,6211
-lizard_languages/csharp.py,sha256=lVi-g-0JjHagqDR5r-lRdi2BuCdtR5aer9CYY-Nzw44,478
+lizard_languages/code_reader.py,sha256=P0PkE4QZBWOEj6cFHA4hj3hcLZLcGnqH31EmtltxlaE,6240
+lizard_languages/csharp.py,sha256=EfFAIOIcJXUUhXTlZApXGSlzG34NZvHM9OSe6m7hpv0,2141
 lizard_languages/erlang.py,sha256=7YJS2cMyXDKEV_kpH8DzBARxFCFcjKuTOPSQ3K52auU,3860
 lizard_languages/fortran.py,sha256=KATDsnfjob5W3579A_VxbwrbTkK7Rx3p0eXdBgjx25I,8973
 lizard_languages/gdscript.py,sha256=KwlGoODilQnFgXvODpq_XlA6fV3hGbN9fd7bsiEUn78,637
 lizard_languages/go.py,sha256=dSbWxtWve7KSRW5i9w4DxhODtJ72EcBNrgp-7Xhn0Sg,465
 lizard_languages/golike.py,sha256=vRIfjTVvc0VmJf27lTOLht55ZF1AQ9wn0Fvu-9WabWk,2858
-lizard_languages/java.py,sha256=mfXCRicmZFZFxPW7QuTOQtAKzOZD3d-uh4tiALcGdX4,1186
-lizard_languages/javascript.py,sha256=dc_P3fS39S-5sefTNKPzi7Hype7WkM3rMKONpd1iklM,4143
-lizard_languages/js_style_language_states.py,sha256=2_dgrXLe113xEdfATByioohGquW428pPo9gI3I1duS4,4257
-lizard_languages/js_style_regex_expression.py,sha256=1d4eK5RR0GBAFg2eDb2cKA_YHIYlxjhG7PXAuMOKnRA,743
-lizard_languages/jsx.py,sha256=trMT1ruo6Wi3kJB0qQYJL8Ms0GFEapqD9_SaTe0vCDk,785
+lizard_languages/java.py,sha256=N9V1nbK_kGN4T2A1xpU1f9wZxGL6UEwVuOCA7D_tjPQ,3036
+lizard_languages/javascript.py,sha256=sGZeTqFqCjcl87ncR-Rmj-HTp-4s4ptoTMxeDgc8Jvw,522
+lizard_languages/js_style_language_states.py,sha256=Ie0eA15rd0gfahdNzUlSkQa-o_j5idTIB82JU32c378,4165
+lizard_languages/js_style_regex_expression.py,sha256=Xgyogch4xElYtCG4EnBKvalHTl3tjRPcIIcIQRRd61I,1970
+lizard_languages/jsx.py,sha256=tNoGFQ9hap2yS5NjRPgxMRlYZY-k5Gn07yI0o815Ghk,3566
 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
@@ -50,17 +50,18 @@ lizard_languages/ruby.py,sha256=gUrFsaS6ZJbjb9CixBHP9n0BxGOb8HsDEg7jJ2bz_80,2187
 lizard_languages/rubylike.py,sha256=dAGZ2wqW8nqaESMU8HkeR9gwQ-q9fmZqE6AANvVZD1Q,3426
 lizard_languages/rust.py,sha256=DG2RkR9JWwcD6gIw-BPzg-Yo_lxQtSvfgHioFWIQm9o,610
 lizard_languages/scala.py,sha256=6Jr_TG945VYqB3o5weD7jN7S4beHt4aVj3r-fmKeMAM,1316
-lizard_languages/script_language.py,sha256=FOzB9Rg5-XTnFDeeRRyIrp2rDomRDHhaPsxsxeCx9GU,539
+lizard_languages/script_language.py,sha256=UUO3Wjkoa-ZqwwvcwvhOr5tg1rVavcrEYx3dNdoYSBc,531
 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=Ey7IxFfF2nwt-MJisEO2FaIOl47m4EPf3jF6x62YTVA,1332
+lizard_languages/tsx.py,sha256=aTxmM_-u-R-pRVXRVyITJxrrFZfCeMe9kxMgaoL-qfk,706
 lizard_languages/ttcn.py,sha256=ygjw_raBmPF-4mgoM8m6CAdyEMpTI-n1kZJK1RL4Vxo,2131
-lizard_languages/typescript.py,sha256=fyJeimadxFXqtfTt8MyVzAg6XqpVZeFJ1qp8RGurXbk,2594
+lizard_languages/typescript.py,sha256=c_Kez4pOGMXhdo6q3HT-clEJDP7LuRIbBkkJSipComU,3568
+lizard_languages/vue.py,sha256=KXUBUo2R1zNF8Pffrz_KsQEN44m5XFRMoGXylxKUeT0,1038
 lizard_languages/zig.py,sha256=NX1iyBstBuJFeAGBOAIaRfrmeBREne2HX6Pt4fXZZTQ,586
-lizard-1.17.14.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
-lizard-1.17.14.dist-info/METADATA,sha256=RhLjrf5029-qdpfH3yGvH35sEaktWyHVmypIZHzhniA,15419
-lizard-1.17.14.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-lizard-1.17.14.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
-lizard-1.17.14.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
-lizard-1.17.14.dist-info/RECORD,,
+lizard-1.17.16.dist-info/LICENSE.txt,sha256=05ZjgQ8Cl1dD9p0BhW-Txzkc5rhCogGJVEuf1GT2Y_M,1303
+lizard-1.17.16.dist-info/METADATA,sha256=m4ndIad8zK__BY3lidM_6WBys_A7GQY0TNDWFq8XIk8,15745
+lizard-1.17.16.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+lizard-1.17.16.dist-info/entry_points.txt,sha256=ZBqPhu-J3NoGGW5vn2Gfyoo0vdVlgBgM-wlNm0SGYUQ,39
+lizard-1.17.16.dist-info/top_level.txt,sha256=5NTrTaOLhHuTzXaGcZPKfuaOgUv7WafNGe0Zl5aycpg,35
+lizard-1.17.16.dist-info/RECORD,,

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_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_ext/version.py

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

@@ -2,7 +2,7 @@
 Language parser for C Sharp
 '''
 
-from .clike import CLikeReader
+from .clike import CLikeReader, CLikeStates, CLikeNestingStackStates
 
 
 class CSharpReader(CLikeReader):
@@ -14,7 +14,49 @@ class CSharpReader(CLikeReader):
     _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_languages/java.py

@@ -19,19 +19,39 @@ class JavaReader(CLikeReader):
 
 
 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
-        super(JavaStates, self)._state_global(token)
+        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
@@ -42,3 +62,28 @@ class JavaStates(CLikeStates):  # pylint: disable=R0903
         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_languages/javascript.py

@@ -6,148 +6,14 @@ 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(CodeReader, CCppCommentsMixin):
+class JavaScriptReader(TypeScriptReader):
     # pylint: disable=R0903
 
     ext = ['js']
     language_names = ['javascript', 'js']
 
-    @staticmethod
-    @js_style_regex_expression
-    def generate_tokens(source_code, addition='', token_class=None):
-        addition = addition +\
-            r"|(?:\$\w+)" + \
-            r"|`.*?`"
-        js_tokenizer = JSTokenizer()
-        for token in CodeReader.generate_tokens(
-                source_code, addition, token_class):
-            for tok in js_tokenizer(token):
-                yield tok
-
     def __init__(self, context):
         super(JavaScriptReader, self).__init__(context)
-        self.parallel_states = [JavaScriptStyleLanguageStates(context)]
-
-
-class Tokenizer(object):
-    def __init__(self):
-        self.sub_tokenizer = None
-        self._ended = False
-
-    def __call__(self, token):
-        if self.sub_tokenizer:
-            for tok in self.sub_tokenizer(token):
-                yield tok
-            if self.sub_tokenizer._ended:
-                self.sub_tokenizer = None
-            return
-        for tok in self.process_token(token):
-            yield tok
-
-    def stop(self):
-        self._ended = True
-
-    def process_token(self, token):
-        pass
-
-
-class JSTokenizer(Tokenizer):
-    def __init__(self):
-        super(JSTokenizer, self).__init__()
-        self.depth = 1
-
-    def process_token(self, token):
-        if token == "<":
-            self.sub_tokenizer = XMLTagWithAttrTokenizer()
-            return
-        if token == "{":
-            self.depth += 1
-        elif token == "}":
-            self.depth -= 1
-            if self.depth == 0:
-                self.stop()
-                return
-        yield token
-
-
-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 = JSTokenizer()
-            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 = JSTokenizer()
-            return self.flush()
-
-
-def isidentifier(token):
-    try:
-        return token.isidentifier()
-    except AttributeError:
-        return token.encode(encoding='UTF-8')[0].isalpha()

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_languages/js_style_regex_expression.py

@@ -6,18 +6,48 @@ import re
 
 
 def js_style_regex_expression(func):
-    def generate_tokens_with_regex(source_code, _=""):
+    def generate_tokens_with_regex(source_code, addition='', token_class=None):
         regx_regx = r"\/(\S*?[^\s\\]\/)+?(igm)*"
         regx_pattern = re.compile(regx_regx)
-        word_pattern = re.compile(r'\w+')
-        tokens = func(source_code, r"|"+regx_regx)
-        leading_by_word = False
-        for token in tokens:
-            if leading_by_word and regx_pattern.match(token):
-                for subtoken in func(token, _):
-                    yield subtoken
+        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:
-                yield token
-            if not token.isspace():
-                leading_by_word = word_pattern.match(token)
+                result.append(token)
+            i += 1
+        return result
     return generate_tokens_with_regex

lizard_languages/jsx.py

@@ -2,17 +2,14 @@
 Language parser for JSX
 '''
 
-from .javascript import JavaScriptReader, JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
+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 JSXReader(JavaScriptReader):
-    # pylint: disable=R0903
-
-    ext = ['jsx']
-    language_names = ['jsx']
-
+class JSXMixin:
+    '''Base mixin class for JSX/TSX shared functionality'''
     @staticmethod
     @js_style_regex_expression
     def generate_tokens(source_code, addition='', token_class=None):
@@ -25,3 +22,106 @@ class JSXReader(JavaScriptReader):
                 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 = JSTokenizer()
+            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 = JSTokenizer()
+            return self.flush()
+
+
+def isidentifier(token):
+    try:
+        return token.isidentifier()
+    except AttributeError:
+        return token.encode(encoding='UTF-8')[0].isalpha()

lizard_languages/script_language.py

@@ -4,7 +4,7 @@ Common behaviours of script languages
 from .code_reader import CodeReader
 
 
-class ScriptLanguageMixIn(object):
+class ScriptLanguageMixIn:
     # pylint: disable=R0903
 
     @staticmethod

lizard_languages/tsx.py

@@ -2,13 +2,13 @@
 Language parser for TSX
 '''
 
-from .typescript import TypeScriptReader, TypeScriptStates
-from .javascript import JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
+from .typescript import TypeScriptReader, TypeScriptStates, JSTokenizer
+from .jsx import JSXMixin
 from .code_reader import CodeReader
 from .js_style_regex_expression import js_style_regex_expression
 
 
-class TSXReader(TypeScriptReader):
+class TSXReader(TypeScriptReader, JSXMixin):
     # pylint: disable=R0903
 
     ext = ['tsx']
@@ -17,28 +17,8 @@ class TSXReader(TypeScriptReader):
     @staticmethod
     @js_style_regex_expression
     def generate_tokens(source_code, addition='', token_class=None):
-        addition = addition +\
-            r"|(?:\$\w+)" + \
-            r"|(?:\<\/\w+\>)" + \
-            r"|`.*?`"
-        js_tokenizer = JSTokenizer()
-        for token in CodeReader.generate_tokens(
-                source_code, addition, token_class):
-            for tok in js_tokenizer(token):
-                yield tok
+        return JSXMixin.generate_tokens(source_code, addition, token_class)
 
     def __init__(self, context):
         super(TSXReader, self).__init__(context)
-        self.parallel_states = [TSXStates(context)]
-
-
-class TSXStates(TypeScriptStates):
-    def _expecting_func_opening_bracket(self, token):
-        if token == '<':
-            self.next(self._expecting_jsx)
-            return
-        super(TSXStates, self)._expecting_func_opening_bracket(token)
-
-    def _expecting_jsx(self, token):
-        if token == '>':
-            self.next(self._expecting_func_opening_bracket) 
+        # No need for parallel states since JSX handling is in the mixin

lizard_languages/typescript.py

@@ -3,12 +3,54 @@ Language parser for JavaScript
 '''
 
 import re
-from .code_reader import CodeReader
+from .code_reader import CodeReader, CodeStateMachine
 from .clike import CCppCommentsMixin
 from .js_style_language_states import JavaScriptStyleLanguageStates
 from .js_style_regex_expression import js_style_regex_expression
 
 
+class Tokenizer(object):
+    def __init__(self):
+        self.sub_tokenizer = None
+        self._ended = False
+
+    def __call__(self, token):
+        if self.sub_tokenizer:
+            for tok in self.sub_tokenizer(token):
+                yield tok
+            if self.sub_tokenizer._ended:
+                self.sub_tokenizer = None
+            return
+        for tok in self.process_token(token):
+            yield tok
+
+    def stop(self):
+        self._ended = True
+
+    def process_token(self, token):
+        pass
+
+
+class JSTokenizer(Tokenizer):
+    def __init__(self):
+        super().__init__()
+        self.depth = 1
+
+    def process_token(self, token):
+        if token == "<":
+            from .jsx import XMLTagWithAttrTokenizer  # Import only when needed
+            self.sub_tokenizer = XMLTagWithAttrTokenizer()
+            return
+        if token == "{":
+            self.depth += 1
+        elif token == "}":
+            self.depth -= 1
+            if self.depth == 0:
+                self.stop()
+                return
+        yield token
+
+
 class TypeScriptReader(CodeReader, CCppCommentsMixin):
     # pylint: disable=R0903
 
@@ -18,58 +60,65 @@ class TypeScriptReader(CodeReader, CCppCommentsMixin):
                        'catch', 'case'])
 
     def __init__(self, context):
-        super(TypeScriptReader, self).__init__(context)
+        super().__init__(context)
         self.parallel_states = [TypeScriptStates(context)]
 
     @staticmethod
     @js_style_regex_expression
     def generate_tokens(source_code, addition='', token_class=None):
         addition = addition +\
-            r"|(?:\w+\?)"
-        return CodeReader.generate_tokens(source_code, addition, token_class)
+            r"|(?:\$\w+)" + \
+            r"|(?:\w+\?)" + \
+            r"|`.*?`"
+        js_tokenizer = JSTokenizer()
+        for token in CodeReader.generate_tokens(
+                source_code, addition, token_class):
+            for tok in js_tokenizer(token):
+                yield tok
 
 
 class TypeScriptStates(JavaScriptStyleLanguageStates):
+    def __init__(self, context):
+        super().__init__(context)
 
     def _state_global(self, token):
-        if token == ':':
-            # When we see a type annotation in global state, store the last tokens
-            # but don't treat it as a function name yet
-            self._potential_name = self.last_tokens
-            self.next(self._type_annotation)
-            return
-        if token == '=>':
-            # For arrow functions, we want to treat them as anonymous
-            self.function_name = ''
-            self._state = self._arrow_function
-            return
-        super(TypeScriptStates, self)._state_global(token)
-
-    def _type_annotation(self, token):
-        if token == '=':
-            # We're back to an assignment, restore the potential name
-            if hasattr(self, '_potential_name'):
-                self.last_tokens = self._potential_name
-                delattr(self, '_potential_name')
-            self.next(self._state_global, token)
-        else:
-            self.next(self._type_annotation)
+        if not self.as_object:
+            if token == ':':
+                self._consume_type_annotation()
+                return
+        super()._state_global(token)
 
     def _expecting_func_opening_bracket(self, token):
         if token == ':':
-            self.next(self._expecting_default)
-            return
-        super(TypeScriptStates, self)._expecting_func_opening_bracket(token)
+            self._consume_type_annotation()
+        else:
+            super()._expecting_func_opening_bracket(token)
+
+    def _consume_type_annotation(self):
+        typeStates = TypeScriptTypeAnnotationStates(self.context)
+
+        def callback():
+            if typeStates.saved_token:
+                self(typeStates.saved_token)
+        self.sub_state(typeStates, callback)
+
 
-    def _expecting_default(self, token):
-        self.next(self._function_return_type)
+class TypeScriptTypeAnnotationStates(CodeStateMachine):
+    def __init__(self, context):
+        super().__init__(context)
+        self.saved_token = None
+
+    def _state_global(self, token):
         if token == '{':
-            self.read_object()
-
-    def _function_return_type(self, token):
-        if token == ';':
-            self.next(self._state_global)
-        elif token == '{':
-            self.next(self._expecting_func_opening_bracket, token)
-        elif token == '=':
-            self.next(self._state_global, token)
+            self.next(self._inline_type_annotation, token)
+        else:
+            self.next(self._state_simple_type, token)
+
+    def _state_simple_type(self, token):
+        if token in '{=;':
+            self.saved_token = token
+            self.statemachine_return()
+
+    @CodeStateMachine.read_inside_brackets_then("{}")
+    def _inline_type_annotation(self, _):
+        self.statemachine_return()

lizard_languages/vue.py

@@ -0,0 +1,34 @@
+'''
+Language parser for Vue.js files
+'''
+
+from .code_reader import CodeReader, CodeStateMachine
+from .typescript import TypeScriptReader
+
+
+class VueReader(TypeScriptReader):
+    # pylint: disable=R0903
+
+    ext = ['vue']
+    language_names = ['vue', 'vuejs']
+
+    def __init__(self, context):
+        super(VueReader, self).__init__(context)
+
+    @staticmethod
+    def generate_tokens(source_code, addition='', token_class=None):
+        # Use the base token generator but ensure we capture Vue block tags
+        addition = addition + r"|(?:\<\/?\w+.*?\>)"
+        return TypeScriptReader.generate_tokens(source_code, addition, token_class)
+
+    def preprocess(self, tokens):
+        current_block = None
+
+        for token in tokens:
+            if token.startswith('<script'):
+                current_block = 'script'
+            elif token.startswith('</script'):
+                current_block = None
+            elif current_block == 'script':
+                if not token.isspace() or token == '\n':
+                    yield token