Merge pull request #44 from Pythagora-io/z_improvements

zvone187 · web-flow · commit 627fdea0b3d0 · 2023-06-22T14:50:42.000+02:00
Z improvements
diff --git a/src/helpers/unitTests.js b/src/helpers/unitTests.js
@@ -13,7 +13,7 @@ const {
     getRelatedFunctions,
     getModuleTypeFromFilePath
 } = require("../utils/code");
-const {getRelativePath, getFolderTreeItem, getTestFilePath, checkPathType, isPathInside} = require("../utils/files");
+const {getRelativePath, getFolderTreeItem, getTestFolderPath, checkPathType, isPathInside} = require("../utils/files");
 const {initScreenForUnitTests} = require("./cmdGUI");
 const {green, red, blue, bold, reset} = require('../utils/cmdPrint').colors;
 
@@ -42,13 +42,13 @@ async function processFile(filePath) {
         let ast = await getAstFromFilePath(filePath);
         let syntaxType = await getModuleTypeFromFilePath(ast);
         processAst(ast, (funcName, path, type) => {
-            if (type === 'exportFnDef') {
-                exportsFn.push(funcName);
-            } else if (type === 'exportFn') {
+            if (type === 'exportFn' || type === 'exportFnDef') {
                 exportsFn.push(funcName);
             } else if (type === 'exportObj') {
                 exportsObj.push(funcName);
-            } else {
+            }
+
+            if (!['exportFn', 'exportObj'].includes(type)) {
                 functions.push({
                     funcName,
                     code: generator(path.node).code,
@@ -96,23 +96,23 @@ async function reformatDataForPythagoraAPI(funcData, filePath, testFilePath) {
         if (file.fileName === filePath) {
             relatedCodeInSameFile = relatedCodeInSameFile.concat(file.functionNames);
         } else {
-            let fileName = getRelativePath(file.fileName, filePath);
+            let fileName = getRelativePath(file.fileName, path.dirname(filePath));
             let code = await stripUnrelatedFunctions(file.fileName, file.functionNames);
             let fullPath = filePath.substring(0, filePath.lastIndexOf('/')) + '/' + fileName;
-            code = replaceRequirePaths(code, filePath, path.resolve(PYTHAGORA_UNIT_DIR) + '/brija.test.js');
+            code = replaceRequirePaths(code, filePath, getTestFolderPath(filePath, rootPath));
             funcData.relatedCode.push({
                 fileName,
                 code,
                 functionNames: file.functionNames,
                 exportedAsObject: file.exportedAsObject,
                 syntaxType: file.syntaxType,
-                pathRelativeToTest: getRelativePath(fullPath, testFilePath + '/brija.test.js')
+                pathRelativeToTest: getRelativePath(fullPath, testFilePath)
             });
         }
     }
     funcData.functionCode = await stripUnrelatedFunctions(filePath, relatedCodeInSameFile);
-    funcData.functionCode = replaceRequirePaths(funcData.functionCode, path.dirname(filePath), path.resolve(PYTHAGORA_UNIT_DIR) + '/brija.test.js');
-    funcData.pathRelativeToTest = getRelativePath(filePath, testFilePath + '/brija.test.js');
+    funcData.functionCode = replaceRequirePaths(funcData.functionCode, path.dirname(filePath), getTestFolderPath(filePath, rootPath));
+    funcData.pathRelativeToTest = getRelativePath(filePath, testFilePath);
     return funcData;
 }
 
@@ -157,14 +157,14 @@ async function createTests(filePath, prefix, funcToTest) {
             );
             spinner.start(folderStructureTree, indexToPush);
 
-            let testFilePath = path.join(getTestFilePath(filePath, rootPath), `/${funcData.functionName}.test.js`);
+            let testFilePath = path.join(getTestFolderPath(filePath, rootPath), `/${funcData.functionName}.test.js`);
             if (fs.existsSync(testFilePath) && !force) {
                 await spinner.stop();
                 folderStructureTree[indexToPush].line = `${green}${folderStructureTree[indexToPush].line}${reset}`;
                 continue;
             }
 
-            let formattedData = await reformatDataForPythagoraAPI(funcData, filePath, getTestFilePath(filePath, rootPath));
+            let formattedData = await reformatDataForPythagoraAPI(funcData, filePath, getTestFolderPath(filePath, rootPath));
             let { tests, error } = await getUnitTests(formattedData, (content) => {
                 scrollableContent.setContent(content);
                 scrollableContent.setScrollPerc(100);
@@ -197,7 +197,7 @@ async function createTests(filePath, prefix, funcToTest) {
 }
 
 async function saveTests(filePath, name, testData) {
-    let dir = getTestFilePath(filePath, rootPath);
+    let dir = getTestFolderPath(filePath, rootPath);
 
     if (!await checkDirectoryExists(dir)) {
         fs.mkdirSync(dir, { recursive: true });
diff --git a/src/utils/code.js b/src/utils/code.js
@@ -212,30 +212,40 @@ function processAst(ast, cb) {
                 const expression = path.node.expression;
                 if (expression && expression.type === 'AssignmentExpression') {
                     const left = expression.left;
-                    if (left.type === 'MemberExpression' &&
+                    if (left.object.type === 'MemberExpression' &&
+                        left.object.object.name === 'module' &&
+                        left.object.property.name === 'exports') {
+                        if (expression.right.type === 'Identifier') {
+                            // module.exports.func1 = func1
+                            return cb(left.property.name, null, 'exportObj');
+                        } else if (expression.right.type === 'FunctionExpression') {
+                            // module.exports.funcName = function() { ... }
+                            // module.exports = function() { ... }
+                            const loc = path.node.loc.start;
+                            let funcName = (left.property.name) || `anon_func_${loc.line}_${loc.column}`;
+                            return cb(funcName, path, 'exportObj');
+                        }
+                    } else if (left.type === 'MemberExpression' &&
                         left.object.name === 'module' &&
                         left.property.name === 'exports') {
-                        // When module.exports is set to a single function
                         if (expression.right.type === 'Identifier') {
+                            // module.exports = func1
                             return cb(expression.right.name, null, 'exportFn');
-                        }
-                        // When module.exports is set to an anonymous function
-                        else if (expression.right.type === 'FunctionExpression') {
+                        } else if (expression.right.type === 'FunctionExpression') {
                             let funcName;
                             if (expression.right.id) {
+                                // module.exports = function func1() { ... }
                                 funcName = expression.right.id.name;
                             } else {
-                                // If function is anonymous, we will generate a name
-                                // based on the file name, line and column number
+                                // module.exports = function() { ... }
                                 const loc = path.node.loc.start;
                                 funcName = `anon_func_${loc.line}_${loc.column}`;
                             }
                             return cb(funcName, path, 'exportFnDef');
-                        }
-                        // When module.exports is set to an object containing multiple functions
-                        else if (expression.right.type === 'ObjectExpression') {
+                        } else if (expression.right.type === 'ObjectExpression') {
                             expression.right.properties.forEach(prop => {
                                 if (prop.type === 'ObjectProperty') {
+                                    // module.exports = { func1 };
                                     return cb(prop.key.name, null, 'exportObj');
                                 }
                             });
@@ -244,7 +254,9 @@ function processAst(ast, cb) {
                     // Handle TypeScript transpiled exports
                     else if (left.type === 'MemberExpression' &&
                         left.object.name === 'exports') {
-                        return cb(left.property.name, null, 'exportFn');
+                        // exports.func1 = function() { ... }
+                        // exports.func1 = func1
+                        return cb(left.property.name, null, 'exportObj');
                     }
                 }
             }
@@ -253,25 +265,39 @@ function processAst(ast, cb) {
             if (path.isExportDefaultDeclaration()) {
                 const declaration = path.node.declaration;
                 if (declaration.type === 'FunctionDeclaration' || declaration.type === 'Identifier') {
+                    // export default func1;
+                    // TODO export default function() { ... }
+                    // TODO cover anonimous functions - add "anon_" name
                     return cb(declaration.id ? declaration.id.name : declaration.name, null, 'exportFn');
                 } else if (declaration.type === 'ObjectExpression') {
                     declaration.properties.forEach(prop => {
                         if (prop.type === 'ObjectProperty') {
+                            // export default { func1: func }
+                            // export default { func1 }
                             return cb(prop.key.name, null, 'exportObj');
                         }
                     });
+                } else if (declaration.type === 'ClassDeclaration') {
+                    // export default class Class1 { ... }
+                    return cb(declaration.id ? declaration.id.name : declaration.name, null, 'exportFnDef');
                 }
             } else if (path.isExportNamedDeclaration()) {
                 if (path.node.declaration) {
                     if (path.node.declaration.type === 'FunctionDeclaration') {
-                        return cb(path.node.declaration.id.name, null, 'exportFn');
+                        // export function func1 () { ... }
+                        // export class Class1 () { ... }
+                        return cb(path.node.declaration.id.name, null, 'exportFnDef');
                     } else if (path.node.declaration.type === 'VariableDeclaration') {
                         path.node.declaration.declarations.forEach(declaration => {
                             return cb(declaration.id.name, null, 'exportFn');
                         });
+                    } else if (path.node.declaration.type === 'ClassDeclaration') {
+                        // export class Class1 { ... }
+                        return cb(path.node.declaration.id.name, null, 'exportFnDef');
                     }
                 } else if (path.node.specifiers.length > 0) {
                     path.node.specifiers.forEach(spec => {
+                        // export { func as func1 }
                         return cb(spec.exported.name, null, 'exportObj');
                     });
                 }
diff --git a/src/utils/files.js b/src/utils/files.js
@@ -8,8 +8,8 @@ async function checkPathType(path) {
     return stats.isFile() ? 'file' : 'directory';
 }
 
-function getRelativePath(filePath, referenceFilePath) {
-    let relativePath = path.relative(path.dirname(referenceFilePath), filePath);
+function getRelativePath(filePath, referenceFolderPath) {
+    let relativePath = path.relative(path.resolve(referenceFolderPath), filePath);
     if (!relativePath.startsWith('../') && !relativePath.startsWith('./')) {
         relativePath = './' + relativePath;
     }
@@ -29,7 +29,7 @@ function isPathInside(basePath, targetPath) {
     return !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
 }
 
-function getTestFilePath(filePath, rootPath) {
+function getTestFolderPath(filePath, rootPath) {
     return path.join(
         path.resolve(PYTHAGORA_UNIT_DIR),
         path.dirname(filePath).replace(rootPath, ''),
@@ -42,5 +42,5 @@ module.exports = {
     getRelativePath,
     getFolderTreeItem,
     isPathInside,
-    getTestFilePath
+    getTestFolderPath
 }

Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ async function checkPathType(path) {`
`8`	`8`	`return stats.isFile() ? 'file' : 'directory';`
`9`	`9`	`}`
`10`	`10`
`11`		`-function getRelativePath(filePath, referenceFilePath) {`
`12`		`- let relativePath = path.relative(path.dirname(referenceFilePath), filePath);`
	`11`	`+function getRelativePath(filePath, referenceFolderPath) {`
	`12`	`+ let relativePath = path.relative(path.resolve(referenceFolderPath), filePath);`
`13`	`13`	`if (!relativePath.startsWith('../') && !relativePath.startsWith('./')) {`
`14`	`14`	`relativePath = './' + relativePath;`
`15`	`15`	`}`
`@@ -29,7 +29,7 @@ function isPathInside(basePath, targetPath) {`
`29`	`29`	`return !relativePath.startsWith('..') && !path.isAbsolute(relativePath);`
`30`	`30`	`}`
`31`	`31`
`32`		`-function getTestFilePath(filePath, rootPath) {`
	`32`	`+function getTestFolderPath(filePath, rootPath) {`
`33`	`33`	`return path.join(`
`34`	`34`	`path.resolve(PYTHAGORA_UNIT_DIR),`
`35`	`35`	`path.dirname(filePath).replace(rootPath, ''),`
`@@ -42,5 +42,5 @@ module.exports = {`
`42`	`42`	`getRelativePath,`
`43`	`43`	`getFolderTreeItem,`
`44`	`44`	`isPathInside,`
`45`		`- getTestFilePath`
	`45`	`+ getTestFolderPath`
`46`	`46`	`}`