lizard 1.17.15__tar.gz → 1.17.17__tar.gz

{lizard-1.17.15 → lizard-1.17.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.15
+Version: 1.17.17
 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/
@@ -137,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.15 → lizard-1.17.17}/README.rst

@@ -106,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.15 → lizard-1.17.17}/lizard.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.15
+Version: 1.17.17
 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/
@@ -137,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.15 → lizard-1.17.17}/lizard.egg-info/requires.txt

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

{lizard-1.17.15 → lizard-1.17.17}/lizard.py

@@ -896,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
@@ -926,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))
 
 
@@ -967,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.15 → lizard-1.17.17}/lizard_ext/version.py

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

lizard-1.17.17/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.17/lizard_languages/java.py

@@ -0,0 +1,142 @@
+'''
+Language parser for Java
+'''
+
+from lizard_languages.code_reader import CodeStateMachine
+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 _state_imp(self, token):
+        def callback():
+            self.next(self._state_global)
+        self.sub_state(JavaFunctionBodyStates(self.context), callback, 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 _try_start_a_class(self, 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 True
+
+    def _state_global(self, token):
+        if token == '@':
+            self._state = self._state_decorator
+            return
+        if self._try_start_a_class(token):
+            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 == '{':
+            def callback():
+                self._state = self._state_global
+            self.sub_state(JavaClassBodyStates(self.class_name, self.is_record, self.context), callback, token)
+        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
+
+class JavaFunctionBodyStates(JavaStates):
+    def __init__(self, context):
+        super(JavaFunctionBodyStates, self).__init__(context)
+
+    @CodeStateMachine.read_inside_brackets_then("{}", "_state_dummy")
+    @CodeStateMachine.read_inside_brackets_then("()", "_state_dummy")
+    def _state_global(self, token):
+        if token == "new":
+            self.next(self._state_new)
+        self._try_start_a_class(token)
+        if self.br_count == 0:
+            self.statemachine_return()
+
+    def _state_dummy(self, _):
+        pass
+
+    def _state_new(self, token):
+        self.next(self._state_new_parameters)
+
+    def _state_new_parameters(self, token):
+        if token == "(":
+            self.sub_state(JavaFunctionBodyStates(self.context), None, token)
+            return
+        if token == "{":
+            def callback():
+                self.next(self._state_global)
+            self.sub_state(JavaClassBodyStates("(anonymous)", False, self.context), callback, token)
+            return
+        self.next(self._state_global)
+
+class JavaClassBodyStates(JavaStates):
+    def __init__(self, class_name, is_record, context):
+        super(JavaClassBodyStates, self).__init__(context)
+        self.class_name = class_name
+        self.is_record = is_record
+
+    def _state_global(self, token):
+        super()._state_global(token)
+        if token == '}':
+            self.statemachine_return()

lizard-1.17.17/lizard_languages/javascript.py

@@ -0,0 +1,15 @@
+'''
+Language parser for JavaScript
+'''
+
+from .typescript import TypeScriptReader 
+
+
+class JavaScriptReader(TypeScriptReader):
+    # pylint: disable=R0903
+
+    ext = ['js', 'cjs', 'mjs']
+    language_names = ['javascript', 'js']
+
+    def __init__(self, context):
+        super(JavaScriptReader, self).__init__(context)

{lizard-1.17.15 → lizard-1.17.17}/lizard_languages/jsx.py

@@ -8,6 +8,20 @@ from .code_reader import CodeReader
 from .js_style_regex_expression import js_style_regex_expression
 
 
+class TSXTokenizer(JSTokenizer):
+    def __init__(self):
+        super().__init__()
+
+    def process_token(self, token):
+        if token == "<":
+            from .jsx import XMLTagWithAttrTokenizer  # Import only when needed
+            self.sub_tokenizer = XMLTagWithAttrTokenizer()
+            return
+    
+        for tok in super().process_token(token):
+            yield tok
+
+
 class JSXMixin:
     '''Base mixin class for JSX/TSX shared functionality'''
     @staticmethod
@@ -17,7 +31,7 @@ class JSXMixin:
             r"|(?:\$\w+)" + \
             r"|(?:\<\/\w+\>)" + \
             r"|`.*?`"
-        js_tokenizer = JSTokenizer()
+        js_tokenizer = TSXTokenizer()
         for token in CodeReader.generate_tokens(
                 source_code, addition, token_class):
             for tok in js_tokenizer(token):
@@ -102,7 +116,7 @@ class XMLTagWithAttrTokenizer(Tokenizer):
             self.state = self._after_tag
         elif token == "{":
             self.cache.append("}")
-            self.sub_tokenizer = JSTokenizer()
+            self.sub_tokenizer = TSXTokenizer()
             self.state = self._after_tag
 
     def _body(self, token):
@@ -116,7 +130,7 @@ class XMLTagWithAttrTokenizer(Tokenizer):
             return self.flush()
 
         if token == '{':
-            self.sub_tokenizer = JSTokenizer()
+            self.sub_tokenizer = TSXTokenizer()
             return self.flush()
 
 

{lizard-1.17.15 → lizard-1.17.17}/lizard_languages/ruby.py

@@ -9,11 +9,12 @@ from .script_language import ScriptLanguageMixIn
 
 class MyToken(str):
     def __new__(cls, value, *_):
-        return super(MyToken, cls).__new__(cls, value.group(0))
+        val = value.group(0) if hasattr(value, 'group') else value
+        return super(MyToken, cls).__new__(cls, val)
 
     def __init__(self, value):
         super(MyToken, self).__init__()
-        self.begin = value.start()
+        self.begin = value.start() if hasattr(value, 'start') else 0
 
 
 class RubyReader(RubylikeReader):

{lizard-1.17.15 → lizard-1.17.17}/lizard_languages/tsx.py

@@ -2,9 +2,8 @@
 Language parser for TSX
 '''
 
-from .typescript import TypeScriptReader, TypeScriptStates, JSTokenizer
+from .typescript import TypeScriptReader
 from .jsx import JSXMixin
-from .code_reader import CodeReader
 from .js_style_regex_expression import js_style_regex_expression
 
 

{lizard-1.17.15 → lizard-1.17.17}/lizard_languages/typescript.py

@@ -37,10 +37,6 @@ class JSTokenizer(Tokenizer):
         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 == "}":
@@ -115,10 +111,18 @@ class TypeScriptTypeAnnotationStates(CodeStateMachine):
             self.next(self._state_simple_type, token)
 
     def _state_simple_type(self, token):
-        if token in '{=;':
+        print(token)
+        if token == '<':
+            print(token)
+            self.next(self._state_generic_type, token)
+        elif token in '{=;':
             self.saved_token = token
             self.statemachine_return()
 
     @CodeStateMachine.read_inside_brackets_then("{}")
     def _inline_type_annotation(self, _):
         self.statemachine_return()
+
+    @CodeStateMachine.read_inside_brackets_then("<>")
+    def _state_generic_type(self, token):
+        self.statemachine_return()

{lizard-1.17.15 → lizard-1.17.17}/setup.py

@@ -95,7 +95,7 @@ setup(
     packages=['lizard_ext', 'lizard_languages'],
     #data_files=[('lizard_ext', [])],
     py_modules=['lizard'],
-    install_requires=['pygments'],
+    install_requires=['pygments', 'pathspec'],
     entry_points={'console_scripts': ['lizard = lizard:main']},
     author='Terry Yin',
     author_email='terry@odd-e.com',

{lizard-1.17.15 → lizard-1.17.17}/test/testFilesFilter.py

@@ -126,3 +126,34 @@ class TestFilesFilter(unittest.TestCase):
         else:
             file_names = ["./f1.cpp", "./f2.cpp"]
         self.assertEqual(file_names, list(files))
+
+    @patch.object(os.path, "exists")
+    @patch.object(os.path, "relpath")
+    @patch.object(os, "walk")
+    @patch("builtins.open", create=True)
+    def test_gitignore_filter(self, mock_open, mock_os_walk, mock_relpath, mock_exists):
+        mock_os_walk.return_value = (['.',
+                                    None,
+                                    ['temp.c', 'node_modules/file.js', 'useful.cpp']], )
+        
+        def exists_side_effect(path):
+            return path.endswith('.gitignore')
+        mock_exists.side_effect = exists_side_effect
+        
+        def relpath_side_effect(path, start):
+            # Return paths in a normalized format
+            if path.startswith('./'):
+                path = path[2:]
+            return path.replace(os.sep, '/')
+        mock_relpath.side_effect = relpath_side_effect
+        
+        mock_file = mock_open.return_value.__enter__.return_value
+        mock_file.readlines.return_value = ["node_modules/\n", "*.c\n"]
+        mock_file.read.return_value = "node_modules/\n*.c\n"
+        
+        files = get_all_source_files(["dir"], [], [])
+        if which_system() == "Windows":
+            file_names = [".\\useful.cpp"]
+        else:
+            file_names = ["./useful.cpp"]
+        self.assertEqual(file_names, list(files))

{lizard-1.17.15 → lizard-1.17.17}/test/testOutput.py

@@ -125,7 +125,7 @@ class TestAllOutput(StreamStdoutTestCase):
     def test_should_not_print_extension_results_when_not_implemented(self):
         file_infos = []
         option = Mock(CCN=15, number = 0, thresholds={}, extensions = [object()], whitelist='')
-        return print_result_with_scheme(file_infos, option)
+        print_result_with_scheme(file_infos, option)
 
     def test_print_result(self):
         file_infos = [FileInformation('f1.c', 1, []), FileInformation('f2.c', 1, [])]

lizard-1.17.17/test/testOutputFile.py

@@ -0,0 +1,117 @@
+from os.path import join
+from shutil import rmtree
+from tempfile import mkdtemp
+import unittest
+from lizard import html_output, print_xml, parse_args, main
+
+
+class TestFileOutputArgParsing(unittest.TestCase):
+
+    def test_short(self):
+        args = parse_args(["lizard", "-o test_file"])
+        self.assertEqual("test_file", args.output_file.strip())
+
+    def test_long(self):
+        args = parse_args(["lizard", "--output_file", "test_file"])
+        self.assertEqual("test_file", args.output_file.strip())
+
+    def test_standalone(self):
+        args = parse_args(["lizard", "--output_file", "test_file.html"])
+        self.assertEqual(html_output, args.printer)
+
+    def test_override(self):
+        args = parse_args(["lizard", "--output_file test_file.html", "--xml"])
+        self.assertEqual(print_xml, args.printer)
+
+
+class TestFileOutputIntegration(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp_dir = mkdtemp()
+        print("Tmp directory '{}' created.\n".format(self.tmp_dir))
+
+    def tearDown(self):
+        rmtree(self.tmp_dir)
+        print("Tmp directory '{}' deleted.\n".format(self.tmp_dir))
+
+    def output_test(self, file_name, expected_first_line):
+        path = join(self.tmp_dir, file_name)
+        args = ["lizard", "--verbose", "--output_file", path, "test/data"]
+        main(args)
+        first_line = open(path, 'r').readline().strip('\n')
+        self.assertEqual(first_line, expected_first_line)
+
+    def test_default(self):
+        header = "================================================"
+        self.output_test("test", header)
+
+    def test_csv(self):
+        header = "NLOC,CCN,token,PARAM,length,location,file,function,long_name,start,end"
+        self.output_test("test.csv", header)
+
+    def test_html(self):
+        header = "<!DOCTYPE HTML PUBLIC"
+        self.output_test("test.html", header)
+
+    def test_xml(self):
+        header = "<?xml version=\"1.0\" ?>"
+        self.output_test("test.xml", header)
+
+    def test_html_output_with_extension(self):
+        """Test that using --html with .html extension works correctly without warnings"""
+        path = join(self.tmp_dir, "test.html")
+        args = ["lizard", "--length", "75", "--CCN", "20", "--arguments", "3",
+               "--warnings_only", "--sort", "cyclomatic_complexity", "--html",
+               "--output_file", path, "test/data"]
+        
+        # Capture stdout to check for warnings
+        import sys
+        from io import StringIO
+        stdout = StringIO()
+        old_stdout = sys.stdout
+        sys.stdout = stdout
+        
+        try:
+            main(args)
+            output = stdout.getvalue()
+            self.assertNotIn("Warning: overriding output file extension", output,
+                           "Should not show extension warning when using .html extension with --html")
+            
+            # Verify the file exists and has HTML content
+            with open(path, 'r') as f:
+                content = f.read()
+                self.assertTrue(content.startswith("<!DOCTYPE HTML PUBLIC"),
+                              "Output file should contain HTML content")
+        finally:
+            sys.stdout = old_stdout
+
+    def test_html_extension_warning(self):
+        """Test that using --html with .html extension works correctly without warnings,
+        but using a different format with .html extension shows a warning"""
+        path = join(self.tmp_dir, "test.html")
+        
+        # Capture stderr to check for warnings
+        import sys
+        from io import StringIO
+        stderr = StringIO()
+        old_stderr = sys.stderr
+        sys.stderr = stderr
+        
+        try:
+            # First test: --html with .html extension should not warn
+            args = ["lizard", "--html", "--output_file", path, "test/data"]
+            main(args)
+            output = stderr.getvalue()
+            self.assertNotIn("Warning: overriding output file extension", output,
+                           "Should not show warning when format matches extension")
+            stderr.truncate(0)
+            stderr.seek(0)
+            
+            # Second test: --xml with .html extension should warn
+            args = ["lizard", "--xml", "--output_file", path, "test/data"]
+            main(args)
+            output = stderr.getvalue()
+            self.assertIn("Warning: overriding output file extension", output,
+                         "Should show warning when format doesn't match extension")
+        finally:
+            sys.stderr = old_stderr

lizard-1.17.15/lizard_languages/csharp.py

@@ -1,20 +0,0 @@
-'''
-Language parser for C Sharp
-'''
-
-from .clike import CLikeReader
-
-
-class CSharpReader(CLikeReader):
-    # pylint: disable=R0903
-
-    ext = ['cs']
-    language_names = ['csharp']
-
-    _conditions = set(['if', 'for', 'while', '&&', '||', '?', 'catch',
-                      'case', '??'])
-
-    @staticmethod
-    def generate_tokens(source_code, addition='', token_class=None):
-        return CLikeReader.generate_tokens(
-                source_code, r"|(?:\?\?)", token_class)

lizard-1.17.15/lizard_languages/java.py

@@ -1,44 +0,0 @@
-'''
-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 _state_old_c_params(self, token):
-        if token == '{':
-            self._state_dec_to_imp(token)
-
-    def try_new_function(self, name):
-        self.context.try_new_function(name)
-        self._state = self._state_function
-
-    def _state_global(self, token):
-        if token == '@':
-            self._state = self._state_decorator
-            return
-        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)

lizard-1.17.15/lizard_languages/javascript.py

@@ -1,19 +0,0 @@
-'''
-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.15/test/testOutputFile.py

@@ -1,58 +0,0 @@
-from os.path import join
-from shutil import rmtree
-from tempfile import mkdtemp
-import unittest
-from lizard import html_output, print_xml, parse_args, main
-
-
-class TestFileOutputArgParsing(unittest.TestCase):
-
-    def test_short(self):
-        args = parse_args(["lizard", "-o test_file"])
-        self.assertEqual("test_file", args.output_file.strip())
-
-    def test_long(self):
-        args = parse_args(["lizard", "--output_file", "test_file"])
-        self.assertEqual("test_file", args.output_file.strip())
-
-    def test_standalone(self):
-        args = parse_args(["lizard", "--output_file", "test_file.html"])
-        self.assertEqual(html_output, args.printer)
-
-    def test_override(self):
-        args = parse_args(["lizard", "--output_file test_file.html", "--xml"])
-        self.assertEqual(print_xml, args.printer)
-
-
-class TestFileOutputIntegration(unittest.TestCase):
-
-    def setUp(self):
-        self.tmp_dir = mkdtemp()
-        print("Tmp directory '{}' created.\n".format(self.tmp_dir))
-
-    def tearDown(self):
-        rmtree(self.tmp_dir)
-        print("Tmp directory '{}' deleted.\n".format(self.tmp_dir))
-
-    def output_test(self, file_name, expected_first_line):
-        path = join(self.tmp_dir, file_name)
-        args = ["lizard", "--verbose", "--output_file", path, "test/data"]
-        main(args)
-        first_line = open(path, 'r').readline().strip('\n')
-        self.assertEqual(first_line, expected_first_line)
-
-    def test_default(self):
-        header = "================================================"
-        self.output_test("test", header)
-
-    def test_csv(self):
-        header = "NLOC,CCN,token,PARAM,length,location,file,function,long_name,start,end"
-        self.output_test("test.csv", header)
-
-    def test_html(self):
-        header = "<!DOCTYPE HTML PUBLIC"
-        self.output_test("test.html", header)
-
-    def test_xml(self):
-        header = "<?xml version=\"1.0\" ?>"
-        self.output_test("test.xml", header)