lizard 1.17.13__tar.gz → 1.17.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.13
+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/
@@ -52,7 +52,8 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -68,6 +69,7 @@ A list of supported languages:
 -  Kotlin
 -  Solidity
 -  Erlang
+-  Zig
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use
@@ -385,5 +387,3 @@ Lizard is also used as a plugin for fastlane to help check code complexity and s
 - `European research project FASTEN (Fine-grained Analysis of SofTware Ecosystems as Networks, <http://fasten-project.eu/)>`_
   - `for a quality analyzer <https://github.com/fasten-project/quality-analyzer>`_
 
-
-

{lizard-1.17.13 → lizard-1.17.15}/README.rst

@@ -21,7 +21,8 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -37,6 +38,7 @@ A list of supported languages:
 -  Kotlin
 -  Solidity
 -  Erlang
+-  Zig
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lizard
-Version: 1.17.13
+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/
@@ -52,7 +52,8 @@ A list of supported languages:
 -  Java
 -  C# (C Sharp)
 -  JavaScript (With ES6 and JSX)
--  TypeScript
+-  TypeScript (With TSX)
+-  VueJS
 -  Objective-C
 -  Swift
 -  Python
@@ -68,6 +69,7 @@ A list of supported languages:
 -  Kotlin
 -  Solidity
 -  Erlang
+-  Zig
 
 By default lizard will search for any source code that it knows and mix
 all the results together. This might not be what you want. You can use
@@ -385,5 +387,3 @@ Lizard is also used as a plugin for fastlane to help check code complexity and s
 - `European research project FASTEN (Fine-grained Analysis of SofTware Ecosystems as Networks, <http://fasten-project.eu/)>`_
   - `for a quality analyzer <https://github.com/fasten-project/quality-analyzer>`_
 
-
-

{lizard-1.17.13 → lizard-1.17.15}/lizard.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ lizard_languages/java.py
 lizard_languages/javascript.py
 lizard_languages/js_style_language_states.py
 lizard_languages/js_style_regex_expression.py
+lizard_languages/jsx.py
 lizard_languages/kotlin.py
 lizard_languages/lua.py
 lizard_languages/objc.py
@@ -63,8 +64,11 @@ lizard_languages/script_language.py
 lizard_languages/solidity.py
 lizard_languages/swift.py
 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
 test/testBasicFunctionInfo.py

{lizard-1.17.13 → lizard-1.17.15}/lizard.egg-info/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 lizard = lizard:main
-

{lizard-1.17.13 → 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))
 
@@ -572,7 +571,9 @@ class FileAnalyzer(object):  # pylint: disable=R0903
             for _ in reader(tokens, reader):
                 pass
         except RecursionError as e:
-            sys.stderr.write("[skip] fail to process '%s' with RecursionError - %s\n" % (filename, e))
+            sys.stderr.write(
+                "[skip] fail to process '%s' with RecursionError - %s\n" %
+                (filename, e))
         return context.fileinfo
 
 
@@ -721,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.13 → 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.13 → lizard-1.17.15}/lizard_ext/version.py

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

{lizard-1.17.13 → lizard-1.17.15}/lizard_languages/__init__.py

@@ -1,5 +1,6 @@
 ''' programming languages of lizard '''
 
+from lizard_languages.zig import ZigReader
 from .clike import CLikeReader
 from .erlang import ErlangReader
 from .java import JavaReader
@@ -20,6 +21,9 @@ from .rust import RustReader
 from .typescript import TypeScriptReader
 from .fortran import FortranReader
 from .solidity import SolidityReader
+from .jsx import JSXReader
+from .tsx import TSXReader
+from .vue import VueReader
 
 
 def languages():
@@ -44,6 +48,10 @@ def languages():
         KotlinReader,
         SolidityReader,
         ErlangReader,
+        ZigReader,
+        JSXReader,
+        TSXReader,
+        VueReader,
     ]
 
 

{lizard-1.17.13 → lizard-1.17.15}/lizard_languages/clike.py

@@ -182,7 +182,7 @@ class CLikeStates(CodeStateMachine):
             self.context.add_to_function_name(' ' + token)
 
     def _state_name_with_space(self, token):
-        self._state = self._state_operator\
+        self._state = self._state_operator \
             if token == 'operator' else self._state_function
         self.context.add_to_function_name(token)
 
@@ -196,7 +196,7 @@ class CLikeStates(CodeStateMachine):
             else:
                 self.next(self._state_global)
         elif len(self.bracket_stack) == 1:
-            if token != 'void': # void is a reserved keyword, meaning no parameters
+            if token != 'void':  # void is a reserved keyword, meaning no parameters
                 self.context.parameter(token)
             return
         self.context.add_to_long_function_name(token)

{lizard-1.17.13 → 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
@@ -117,11 +118,13 @@ class CodeReader:
         def _generate_tokens(source, add, flags=0):
             # DO NOT put any sub groups in the regex. Good for performance
             _until_end = r"(?:\\\n|[^\n])*"
-            combined_symbols = ["<<=", ">>=", "||", "&&", "===", "!==",
-                                "==", "!=", "<=", ">=", "->", "=>",
-                                "++", "--", '+=', '-=',
-                                "+", "-", '*', '/',
-                                '*=', '/=', '^=', '&=', '|=', "..."]
+            combined_symbols = [
+                "<<=", ">>=", "||", "&&", "===", "!==",
+                "==", "!=", "<=", ">=", "->", "=>",
+                "++", "--", '+=', '-=',
+                "+", "-", '*', '/',
+                '*=', '/=', '^=', '&=', '|=', "..."
+            ]
             token_pattern = re.compile(
                 r"(?:" +
                 r"\/\*.*?\*\/" +
@@ -171,8 +174,12 @@ class CodeReader:
         pattern = re.compile(r'\(\?[aiLmsux]+\)')
         re_flags = ''.join(opt[2:-1] for opt in pattern.findall(addition))
         flags = reduce(or_, (flag_dict[flag] for flag in re_flags), 0)
+        cleaned_addition = pattern.sub('', addition)
 
-        return _generate_tokens(source_code, pattern.sub('', addition), flags=flags)
+        return _generate_tokens(
+            source_code,
+            cleaned_addition,
+            flags=flags)
 
     def __call__(self, tokens, reader):
         self.context = reader.context

{lizard-1.17.13 → lizard-1.17.15}/lizard_languages/erlang.py

@@ -26,8 +26,12 @@ class ErlangReader(CodeReader):
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
-        return map(lambda x: x[1], filter(lambda x: x[0] != py_token.Whitespace,
-                                          lex(source_code, lexer=lexers.get_lexer_by_name('erlang'))))
+        lexer = lexers.get_lexer_by_name('erlang')
+        tokens = lex(source_code, lexer=lexer)
+        return map(
+            lambda x: x[1],
+            filter(lambda x: x[0] != py_token.Whitespace, tokens)
+        )
 
 
 class ErlangStates(CodeStateMachine):
@@ -77,8 +81,8 @@ class ErlangStates(CodeStateMachine):
         if token == '-':
             self.punctuated = True
         elif token == '>' and self.punctuated:
-            if len(self.context.stacked_functions) <= 1 or \
-                    self.context.current_function.name == 'fun':
+            if (len(self.context.stacked_functions) <= 1 or
+                    self.context.current_function.name == 'fun'):
                 self.next(self._state_func_first_line, token)
         else:
             self.func_match_failed(token)
@@ -93,8 +97,8 @@ class ErlangStates(CodeStateMachine):
 
     def _state_nested_end(self, token):
         if token == '.' or token == ',':
-            if len(self.context.stacked_functions) > 1 \
-                    and self.context.stacked_functions[-1].name == 'fun':
+            if (len(self.context.stacked_functions) > 1 and
+                    self.context.stacked_functions[-1].name == 'fun'):
                 self.statemachine_return()
                 return
 

{lizard-1.17.13 → lizard-1.17.15}/lizard_languages/fortran.py

@@ -6,57 +6,65 @@ import re
 from .code_reader import CodeStateMachine, CodeReader
 
 
-# pylint: disable=R0903
-class FortranCommentsMixin(object):
+class FortranCommentsMixin:
     @staticmethod
     def get_comment_from_token(token):
         if token.startswith('!'):
             return token[1:]
 
 
-# pylint: disable=R0903
 class FortranReader(CodeReader, FortranCommentsMixin):
-    ''' This is the reader for Fortran. '''
+    '''This is the reader for Fortran.'''
 
     ext = ['f70', 'f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp']
     language_names = ['fortran']
-    _conditions = set((
+
+    # Conditions need to have all the cases because the matching is case-insensitive
+    # and is not done here.
+    _conditions = {
         'IF', 'DO', '.AND.', '.OR.', 'CASE',
-        'if', 'do', '.and.', '.or.', 'case'))
-    _blocks = ['PROGRAM', 'MODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE', 'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE']
+        'if', 'do', '.and.', '.or.', 'case'
+    }
+    _blocks = [
+        'PROGRAM', 'MODULE', 'SUBMODULE', 'SUBROUTINE', 'FUNCTION', 'TYPE',
+        'INTERFACE', 'BLOCK', 'IF', 'DO', 'FORALL', 'WHERE', 'SELECT', 'ASSOCIATE'
+    ]
 
     def __init__(self, context):
-        super(FortranReader, self).__init__(context)
+        super().__init__(context)
         self.macro_disabled = False
         self.parallel_states = [FortranStates(context, self)]
 
     @staticmethod
     def generate_tokens(source_code, addition='', token_class=None):
         _until_end = r'(?:\\\n|[^\n])*'
-        return CodeReader.generate_tokens(
-            source_code,
+        block_endings = '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)
+        # Include all patterns and the (?i) flag in addition
+        addition = (
             r'(?i)'
-            r'\/\/' +
-            r'|\#' + _until_end +
-            r'|\!' + _until_end +
-            r'|^\*' + _until_end +
-            r'|\.OR\.' +
-            r'|\.AND\.' +
-            r'|ELSE +IF' +
-            ''.join(r'|END[ \t]+{0}'.format(_) for _ in FortranReader._blocks) +
-            addition,
-            token_class)
+            r'\/\/|'
+            r'\#' + _until_end + r'|'
+            r'\!' + _until_end + r'|'
+            r'^\*' + _until_end + r'|'
+            r'\.OR\.|'
+            r'\.AND\.|'
+            r'ELSE\s+IF|'
+            r'MODULE\s+PROCEDURE|'
+            + block_endings + addition
+        )
+        return CodeReader.generate_tokens(
+            source_code, addition=addition, token_class=token_class)
 
     def preprocess(self, tokens):
         macro_depth = 0
         new_line = True
         for token in tokens:
-            if new_line and token[0].upper() in ('c', 'C', '*'):
-                token = '!'+token[1:]
+            if new_line and token[0].upper() in ('C', '*'):
+                token = '!' + token[1:]
             new_line = token == '\n'
-            macro = re.match(r'#\s*(\w+)', token)
-            if macro:
-                macro = macro.group(1).lower()
+            macro_match = re.match(r'#\s*(\w+)', token)
+            if macro_match:
+                macro = macro_match.group(1).lower()
                 if macro in ('if', 'ifdef', 'ifndef', 'elif'):
                     self.context.add_condition()
                 if macro_depth > 0:
@@ -66,22 +74,29 @@ class FortranReader(CodeReader, FortranCommentsMixin):
                         macro_depth -= 1
                 elif macro in ('else', 'elif'):
                     macro_depth += 1
-                # In order to don't mess the nesting,
-                # only the first branch of #if #elif #else
-                # is read by the FortranStateMachine
+                # Only the first branch of #if #elif #else is read
                 self.macro_disabled = macro_depth != 0
             elif not token.isspace() or token == '\n':
                 yield token
 
-# pylint: disable=R0903
+
 class FortranStates(CodeStateMachine):
-    # pylint: disable=line-too-long
-    # pylint: disable=protected-access
-    _ends = re.compile('(?:'+'|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks)+')', re.I)
+    _ends = re.compile(
+        '|'.join(r'END\s*{0}'.format(_) for _ in FortranReader._blocks), re.I)
+
+    # Define token groups to eliminate duplication
+    IGNORE_NEXT_TOKENS = {'%', '::', 'SAVE', 'DATA'}
+    IGNORE_VAR_TOKENS = {'INTEGER', 'REAL', 'COMPLEX', 'LOGICAL', 'CHARACTER'}
+    RESET_STATE_TOKENS = {'RECURSIVE', 'ELEMENTAL'}
+    FUNCTION_NAME_TOKENS = {'SUBROUTINE', 'FUNCTION'}
+    NESTING_KEYWORDS = {'FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'}
+    PROCEDURE_TOKENS = {'PROCEDURE', 'MODULE PROCEDURE'}
 
     def __init__(self, context, reader):
-        super(FortranStates, self).__init__(context)
+        super().__init__(context)
         self.reader = reader
+        self.last_token = None
+        self.in_interface = False
 
     def __call__(self, token, reader=None):
         if self.reader.macro_disabled:
@@ -96,28 +111,35 @@ class FortranStates(CodeStateMachine):
 
     def _state_global(self, token):
         token_upper = token.upper()
-        if token_upper in ('%', '::', 'SAVE', 'DATA'):
+        if token_upper in self.IGNORE_NEXT_TOKENS:
             self._state = self._ignore_next
-        elif token_upper in ('INTEGER', 'REAL','COMPLEX','LOGICAL', 'CHARACTER'):
+        elif token_upper in self.IGNORE_VAR_TOKENS:
             self._state = self._ignore_var
         elif token == '(':
             self.next(self._ignore_expr, token)
-        elif token_upper in ('PROGRAM',):
+        elif token_upper in self.RESET_STATE_TOKENS:
+            self.reset_state()
+        elif token_upper in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token_upper == 'PROGRAM':
             self._state = self._namespace
         elif token_upper == 'MODULE':
+            self._state = self._module_or_procedure
+        elif token_upper == 'SUBMODULE':
             self._state = self._module
-        elif token_upper in ('SUBROUTINE', 'FUNCTION'):
-            self._state = self._function_name
+            self._module(token)
         elif token_upper == 'TYPE':
             self._state = self._type
         elif token_upper == 'IF':
             self._state = self._if
-        elif token_upper in ('BLOCK',):
+        elif token_upper == 'BLOCK':
             self._state = self._ignore_if_paren
-        elif token_upper in ('DO',):
+        elif token_upper == 'DO':
             self._state = self._ignore_if_label
-        elif token_upper in ('FORALL', 'WHERE', 'SELECT', 'INTERFACE', 'ASSOCIATE'):
+        elif token_upper in self.NESTING_KEYWORDS:
             self.context.add_bare_nesting()
+            if token_upper == 'INTERFACE':
+                self.in_interface = True
         elif token_upper == 'ELSE':
             self.context.pop_nesting()
             self.context.add_bare_nesting()
@@ -127,6 +149,9 @@ class FortranStates(CodeStateMachine):
                 self.context.add_condition()
             self._state = self._if
         elif token_upper == 'END' or self._ends.match(token):
+            end_token_upper = token_upper.replace(' ', '')
+            if end_token_upper.startswith('ENDINTERFACE'):
+                self.in_interface = False
             self.context.pop_nesting()
 
     def reset_state(self, token=None):
@@ -134,12 +159,11 @@ class FortranStates(CodeStateMachine):
         if token is not None:
             self._state_global(token)
 
-    # pylint: disable=unused-argument
     def _ignore_next(self, token):
         self.reset_state()
 
     def _ignore_var(self, token):
-        if token.upper() in ('SUBROUTINE', 'FUNCTION'):
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
             self.reset_state(token)
         else:
             self.reset_state()
@@ -152,7 +176,7 @@ class FortranStates(CodeStateMachine):
             self.reset_state()
 
     def _ignore_if_label(self, token):
-        if all(char in "0123456789" for char in token):
+        if token.isdigit():
             self.reset_state()
         else:
             self.context.add_bare_nesting()
@@ -184,11 +208,24 @@ class FortranStates(CodeStateMachine):
         self.reset_state(token)
 
     def _module(self, token):
-        if token.upper() == 'PROCEDURE':
-            self.reset_state()
+        if token.upper() in self.FUNCTION_NAME_TOKENS:
+            self._state = self._function_name
+        elif token.upper() in self.PROCEDURE_TOKENS:
+            self._state = self._procedure
         else:
             self._namespace(token)
 
+    def _procedure(self, token):
+        # Start a new function regardless of context
+        if self.last_token and self.last_token.upper() == 'MODULE':
+            # For "module procedure" case, use the current token as function name
+            self.context.restart_new_function(token)
+        else:
+            # For standalone "procedure" case
+            self.context.restart_new_function(token)
+        self.context.add_bare_nesting()
+        self.reset_state()
+
     def _type(self, token):
         if token in (',', '::') or token[0].isalpha():
             self._namespace(token)
@@ -210,8 +247,15 @@ class FortranStates(CodeStateMachine):
         pass
 
     def _if_then(self, token):
-        if token.upper() == 'THEN':
+        token_upper = token.upper()
+        if token_upper == 'THEN':
             self.context.add_bare_nesting()
             self.reset_state()
         else:
             self.reset_state(token)
+
+    def _module_or_procedure(self, token):
+        if token.upper() == 'PROCEDURE':
+            self._state = self._procedure
+        else:
+            self._module(token)

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)