lizard 1.17.14__tar.gz → 1.17.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.14
+Version: 1.17.15
 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

{lizard-1.17.14 → lizard-1.17.15}/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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.14
+Version: 1.17.15
 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

{lizard-1.17.14 → lizard-1.17.15}/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.15}/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())

{lizard-1.17.14 → lizard-1.17.15}/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.15}/lizard_ext/version.py

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

{lizard-1.17.14 → lizard-1.17.15}/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.15}/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.15/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.15}/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.15/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

lizard-1.17.14/lizard_languages/javascript.py → lizard-1.17.15/lizard_languages/jsx.py

@@ -1,24 +1,21 @@
 '''
-Language parser for JavaScript
+Language parser for JSX
 '''
 
+from .javascript import JavaScriptReader
+from .typescript import JSTokenizer, Tokenizer
 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
 
 
-class JavaScriptReader(CodeReader, CCppCommentsMixin):
-    # pylint: disable=R0903
-
-    ext = ['js']
-    language_names = ['javascript', 'js']
-
+class JSXMixin:
+    '''Base mixin class for JSX/TSX shared functionality'''
     @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(
@@ -26,50 +23,27 @@ class JavaScriptReader(CodeReader, CCppCommentsMixin):
             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
+    def _expecting_func_opening_bracket(self, token):
+        if token == '<':
+            self.next(self._expecting_jsx)
             return
-        for tok in self.process_token(token):
-            yield tok
+        super()._expecting_func_opening_bracket(token)
 
-    def stop(self):
-        self._ended = True
+    def _expecting_jsx(self, token):
+        if token == '>':
+            self.next(self._expecting_func_opening_bracket)
 
-    def process_token(self, token):
-        pass
 
+class JSXReader(JavaScriptReader, JSXMixin):
+    # pylint: disable=R0903
 
-class JSTokenizer(Tokenizer):
-    def __init__(self):
-        super(JSTokenizer, self).__init__()
-        self.depth = 1
+    ext = ['jsx']
+    language_names = ['jsx']
 
-    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
+    @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):

{lizard-1.17.14 → lizard-1.17.15}/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-1.17.15/lizard_languages/tsx.py

@@ -0,0 +1,24 @@
+'''
+Language parser for TSX
+'''
+
+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, JSXMixin):
+    # pylint: disable=R0903
+
+    ext = ['tsx']
+    language_names = ['tsx']
+
+    @staticmethod
+    @js_style_regex_expression
+    def generate_tokens(source_code, addition='', token_class=None):
+        return JSXMixin.generate_tokens(source_code, addition, token_class)
+
+    def __init__(self, context):
+        super(TSXReader, self).__init__(context)
+        # No need for parallel states since JSX handling is in the mixin

lizard-1.17.15/lizard_languages/typescript.py

@@ -0,0 +1,124 @@
+'''
+Language parser for JavaScript
+'''
+
+import re
+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
+
+    ext = ['ts']
+    language_names = ['typescript', 'ts']
+    _conditions = set(['if', 'elseif', 'for', 'while', '&&', '||', '?',
+                       'catch', 'case'])
+
+    def __init__(self, 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+)" + \
+            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 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._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)
+
+
+class TypeScriptTypeAnnotationStates(CodeStateMachine):
+    def __init__(self, context):
+        super().__init__(context)
+        self.saved_token = None
+
+    def _state_global(self, token):
+        if 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-1.17.15/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

lizard-1.17.14/lizard_languages/js_style_regex_expression.py

@@ -1,23 +0,0 @@
-'''
-generate token with javascript style regular expression.
-'''
-
-import re
-
-
-def js_style_regex_expression(func):
-    def generate_tokens_with_regex(source_code, _=""):
-        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
-            else:
-                yield token
-            if not token.isspace():
-                leading_by_word = word_pattern.match(token)
-    return generate_tokens_with_regex

lizard-1.17.14/lizard_languages/jsx.py

@@ -1,27 +0,0 @@
-'''
-Language parser for JSX
-'''
-
-from .javascript import JavaScriptReader, JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
-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']
-
-    @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

lizard-1.17.14/lizard_languages/tsx.py

@@ -1,44 +0,0 @@
-'''
-Language parser for TSX
-'''
-
-from .typescript import TypeScriptReader, TypeScriptStates
-from .javascript import JSTokenizer, XMLTagWithAttrTokenizer, isidentifier
-from .code_reader import CodeReader
-from .js_style_regex_expression import js_style_regex_expression
-
-
-class TSXReader(TypeScriptReader):
-    # pylint: disable=R0903
-
-    ext = ['tsx']
-    language_names = ['tsx']
-
-    @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
-
-    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) 

lizard-1.17.14/lizard_languages/typescript.py

@@ -1,75 +0,0 @@
-'''
-Language parser for JavaScript
-'''
-
-import re
-from .code_reader import CodeReader
-from .clike import CCppCommentsMixin
-from .js_style_language_states import JavaScriptStyleLanguageStates
-from .js_style_regex_expression import js_style_regex_expression
-
-
-class TypeScriptReader(CodeReader, CCppCommentsMixin):
-    # pylint: disable=R0903
-
-    ext = ['ts']
-    language_names = ['typescript', 'ts']
-    _conditions = set(['if', 'elseif', 'for', 'while', '&&', '||', '?',
-                       'catch', 'case'])
-
-    def __init__(self, context):
-        super(TypeScriptReader, self).__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)
-
-
-class TypeScriptStates(JavaScriptStyleLanguageStates):
-
-    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)
-
-    def _expecting_func_opening_bracket(self, token):
-        if token == ':':
-            self.next(self._expecting_default)
-            return
-        super(TypeScriptStates, self)._expecting_func_opening_bracket(token)
-
-    def _expecting_default(self, token):
-        self.next(self._function_return_type)
-        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)