Add Javascript undeclared functions

Author: minhna1112

src/codetext/parser/javascript_parser.py

@@ -48,7 +48,12 @@ def get_comment_node(function_node):
 
     @staticmethod
     def get_function_list(node):
-        function_types = ['function_declaration', 'function', 'method_definition', 'generator_function_declaration']
+        function_types = ['function_declaration',
+                    'function',
+                    'method_definition',
+                    'generator_function_declaration',
+                    'arrow_function',
+                    'generator_function']
         res = get_node_by_kind(node, function_types)
         for node in res[:]:
             if not node.children:
@@ -87,6 +92,16 @@ def get_function_metadata(function_node, blob: str=None) -> Dict[str, str]:
         return_statement = get_node_by_kind(function_node, ['return_statement'])
         if len(return_statement) > 0:
             metadata['return_type'] = '<not_specific>'
+            
+        if function_node.type in ["function",
+                                  "arrow_function",
+                                  "generator_function"]:
+            # function inside object property or variable declarator
+            identifier = function_node.prev_named_sibling
+            if identifier:
+                if identifier.type in ["identifier"]:
+                    metadata["identifier"] = identifier.text.decode()
+        
         return metadata
 
     @staticmethod

tests/test_parser/test_javascript.py

@@ -76,8 +76,8 @@ class Car {
     def test_get_function_metadata(self):
         root = self.root_node
 
-        function = JavascriptParser.get_function_list(root)[1]
-        metadata = JavascriptParser.get_function_metadata(function)
+        _function = JavascriptParser.get_function_list(root)[1]
+        metadata = JavascriptParser.get_function_metadata(_function)
 
         for key in ['identifier', 'parameters', 'return_type']:
             self.assertTrue(key in metadata.keys())
@@ -109,6 +109,57 @@ def test_get_class_metadata(self):
     def test_extract_docstring(self):
         pass
 
+        
+    def test_metadata_with_arrow_function(self):
+        code_sample = '''
+            export const parseModel = async (mesh) =>
+                new Promise((resolve) => {
+                    exporter.parse(
+                        mesh,
+                        (gltf) => {
+                            const blob = new Blob([gltf], { type: "application/octet-stream" });
+                            resolve(blob);
+                            return blob;
+                        },
+                        (error) => {
+                            console.log(error);
+                            return error;
+
+                        }
+                    );
+                });        
+        '''
+        root = parse_code(code_sample, 'javascript').root_node
+        fn = JavascriptParser.get_function_list(root)[0]
+        metadata = JavascriptParser.get_function_metadata(fn)
+        
+        identifier = metadata['identifier']
+        self.assertEqual(identifier, 'parseModel')
+        
+    def test_metadata_with_undecleared_functions(self):
+        code_sample = """
+            const asyncFunctionExpression = async function() {
+                // async function expression definition
+                return a 
+            };
+            
+            const generatorFunctionExpression = function*() {
+                // generator function expression definition
+                return b
+            };        
+        """
+        root = parse_code(code_sample, 'javascript').root_node
+        fn1, fn2 = JavascriptParser.get_function_list(root)
+        
+        self.assertEqual(fn1.type, 'function') 
+        self.assertEqual(fn2.type, 'generator_function')
+        
+        metadata1 = JavascriptParser.get_function_metadata(fn1)
+        metadata2 = JavascriptParser.get_function_metadata(fn2)
+
+        self.assertEqual(metadata1['identifier'], 'asyncFunctionExpression')
+        self.assertEqual(metadata2['identifier'], 'generatorFunctionExpression')
+
 
 if __name__ == '__main__':
     unittest.main()