@zohodesk/codestandard-validator 1.4.2 → 1.4.3

package/build/mutation/fileResolver.js

@@ -198,4 +198,233 @@ FileResolver.prototype.collectSourceFiles = function (srcDir) {
 FileResolver.prototype.collectTestFiles = function (testDir) {
   return this.collectFiles(testDir, '**/*.{test,spec}.{js,ts,jsx,tsx}');
 };
-module.exports = FileResolver;
+module.exports = FileResolver;
+
+// "use strict";
+
+// const path = require('path');
+// const fs = require('fs');
+// const glob = require('glob');
+// const {
+//   getRootDirectory
+// } = require('../utils/General/RootDirectoryUtils/getRootDirectory');
+
+// /**
+//  * FileResolver — resolves source ↔ test file pairs.
+//  *
+//  * Uses heuristic strategies (co-located, __tests__/, mirrored dirs)
+//  * to find a test file for every source file and vice versa.
+//  *
+//  * Compatible with Node 16+.
+//  */
+// function FileResolver(options) {
+//   options = options || {};
+//   this._rootdir = getRootDirectory();
+//   this._cwd = options.cwd || process.cwd();
+//   this._testSuffixes = options.testSuffixes || ['.test.js', '.test.ts', '.test.jsx', '.test.tsx'];
+//   this._sourceExtensions = options.sourceExtensions || ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+// }
+
+// /* ------------------------------------------------------------------ */
+// /*  Source → Test                                                       */
+// /* ------------------------------------------------------------------ */
+
+// FileResolver.prototype.findTestForSource = function (sourceFile) {
+//   var parsed = path.parse(sourceFile);
+//   var dir = parsed.dir;
+//   var name = parsed.name;
+//   var candidate, i, j, k;
+
+//   // Strategy 1: co-located  (src/foo.js → src/foo.test.js)
+//   for (i = 0; i < this._testSuffixes.length; i++) {
+//     candidate = path.join(dir, name + this._testSuffixes[i]);
+//     if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//       return candidate;
+//     }
+//   }
+
+//   // Strategy 2: __tests__ subdir  (src/foo.js → src/__tests__/foo.test.js)
+//   // Also walks up ancestor directories (e.g., src/a/b/foo.js → src/a/__tests__/foo.test.js)
+//   var ancestorDir = dir;
+//   while (ancestorDir && ancestorDir !== '.') {
+//     for (i = 0; i < this._testSuffixes.length; i++) {
+//       candidate = path.join(ancestorDir, '__tests__', name + this._testSuffixes[i]);
+//       if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//         return candidate;
+//       }
+//     }
+//     var parentOfAncestor = path.dirname(ancestorDir);
+//     if (parentOfAncestor === ancestorDir) break;
+//     ancestorDir = parentOfAncestor;
+//   }
+
+//   // Strategy 3: mirror structure  (src/x/foo.js → test/x/foo.test.js)
+//   var testDirs = ['test', 'tests', '__tests__'];
+//   var srcDirs = ['src', 'lib'];
+//   for (i = 0; i < srcDirs.length; i++) {
+//     var srcIdx = dir.indexOf(srcDirs[i] + '/');
+//     if (srcIdx !== -1) {
+//       var relativePath = dir.substring(srcIdx + srcDirs[i].length);
+//       var prefix = dir.substring(0, srcIdx);
+//       for (j = 0; j < testDirs.length; j++) {
+//         for (k = 0; k < this._testSuffixes.length; k++) {
+//           candidate = path.join(prefix, testDirs[j], relativePath, name + this._testSuffixes[k]);
+//           if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//             return candidate;
+//           }
+//         }
+//       }
+//     }
+//   }
+//   return null;
+// };
+
+// /* ------------------------------------------------------------------ */
+// /*  Test → Source                                                        */
+// /* ------------------------------------------------------------------ */
+
+// FileResolver.prototype.findSourceForTest = function (testFile) {
+//   var parsed = path.parse(testFile);
+//   var dir = parsed.dir;
+//   var name = parsed.name;
+//   var candidate, i, j, k;
+
+//   // Strip .test / .spec suffix
+//   var suffixes = ['.test', '.spec'];
+//   for (i = 0; i < suffixes.length; i++) {
+//     if (name.slice(-suffixes[i].length) === suffixes[i]) {
+//       name = name.slice(0, -suffixes[i].length);
+//       break;
+//     }
+//   }
+
+//   // Strategy 1: co-located
+//   for (i = 0; i < this._sourceExtensions.length; i++) {
+//     candidate = path.join(dir, name + this._sourceExtensions[i]);
+//     if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//       return candidate;
+//     }
+//   }
+
+//   // Strategy 2: parent of __tests__
+//   // Walk up from __tests__ checking parent dirs and their subdirs
+//   if (dir.indexOf('__tests__') !== -1) {
+//     var parentDir = dir.replace(/__tests__\/?.*$/, '');
+//     // Check direct parent
+//     for (i = 0; i < this._sourceExtensions.length; i++) {
+//       candidate = path.join(parentDir, name + this._sourceExtensions[i]);
+//       if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//         return candidate;
+//       }
+//     }
+//     // Check subdirs of parent (e.g., _store/__tests__/foo.test.js → _store/helpers/foo.js)
+//     var subDirs = [];
+//     try {
+//       var entries = fs.readdirSync(path.resolve(this._rootdir, parentDir), { withFileTypes: true });
+//       subDirs = entries.filter(function(e) { return e.isDirectory() && e.name !== '__tests__'; }).map(function(e) { return e.name; });
+//     } catch (e) { /* ignore */ }
+//     for (i = 0; i < subDirs.length; i++) {
+//       for (j = 0; j < this._sourceExtensions.length; j++) {
+//         candidate = path.join(parentDir, subDirs[i], name + this._sourceExtensions[j]);
+//         if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//           return candidate;
+//         }
+//       }
+//     }
+//   }
+
+//   // Strategy 3: mirror test → src/lib
+//   var testDirs = ['test', 'tests', '__tests__'];
+//   var srcDirs = ['src', 'lib'];
+//   for (i = 0; i < testDirs.length; i++) {
+//     var testIdx = dir.indexOf(testDirs[i] + '/');
+//     if (testIdx !== -1) {
+//       var relativePath = dir.substring(testIdx + testDirs[i].length);
+//       var prefix = dir.substring(0, testIdx);
+//       for (j = 0; j < srcDirs.length; j++) {
+//         for (k = 0; k < this._sourceExtensions.length; k++) {
+//           candidate = path.join(prefix, srcDirs[j], relativePath, name + this._sourceExtensions[k]);
+//           if (fs.existsSync(path.resolve(this._rootdir, candidate))) {
+//             return candidate;
+//           }
+//         }
+//       }
+//     }
+//   }
+//   return null;
+// };
+
+// /* ------------------------------------------------------------------ */
+// /*  Pair resolution                                                     */
+// /* ------------------------------------------------------------------ */
+
+// FileResolver.prototype.resolveSourceTestPairs = function (sourceFiles, testFiles) {
+//   var pairs = [];
+//   var resolvedSources = {};
+//   var resolvedTests = {};
+//   var i, normalizedSource, normalizedTest, test, source;
+
+//   // Map source → test
+//   for (i = 0; i < sourceFiles.length; i++) {
+//     normalizedSource = sourceFiles[i].replace(/\\/g, '/');
+//     test = this.findTestForSource(normalizedSource);
+//     if (test) {
+//       normalizedTest = test.replace(/\\/g, '/');
+//       pairs.push({
+//         source: normalizedSource,
+//         test: normalizedTest
+//       });
+//       resolvedSources[normalizedSource] = true;
+//       resolvedTests[normalizedTest] = true;
+//     } else {
+//       pairs.push({
+//         source: normalizedSource,
+//         test: null
+//       });
+//       resolvedSources[normalizedSource] = true;
+//     }
+//   }
+
+//   // Map remaining test → source
+//   for (i = 0; i < testFiles.length; i++) {
+//     normalizedTest = testFiles[i].replace(/\\/g, '/');
+//     if (resolvedTests[normalizedTest]) continue;
+//     source = this.findSourceForTest(normalizedTest);
+//     if (source && !resolvedSources[source.replace(/\\/g, '/')]) {
+//       pairs.push({
+//         source: source.replace(/\\/g, '/'),
+//         test: normalizedTest
+//       });
+//       resolvedSources[source.replace(/\\/g, '/')] = true;
+//     }
+//     resolvedTests[normalizedTest] = true;
+//   }
+//   return pairs;
+// };
+
+// /* ------------------------------------------------------------------ */
+// /*  File collectors (glob-based)                                        */
+// /* ------------------------------------------------------------------ */
+
+// FileResolver.prototype.collectFiles = function (directory, pattern) {
+//   var fullPattern = path.join(directory, pattern || '**/*.{js,ts,jsx,tsx}').replace(/\\/g, '/');
+//   try {
+//     return glob.sync(fullPattern, {
+//       cwd: this._rootdir,
+//       nodir: true
+//     });
+//   } catch (err) {
+//     throw new Error("Failed to collect files from '" + directory + "': " + err.message);
+//   }
+// };
+// FileResolver.prototype.collectSourceFiles = function (srcDir) {
+//   var allFiles = this.collectFiles(srcDir, '**/*.{js,ts,jsx,tsx,mjs,cjs}');
+//   var testPattern = /\.(test|spec)\.(js|ts|jsx|tsx|mjs|cjs)$/;
+//   return allFiles.filter(function (f) {
+//     return !testPattern.test(f);
+//   });
+// };
+// FileResolver.prototype.collectTestFiles = function (testDir) {
+//   return this.collectFiles(testDir, '**/*.{test,spec}.{js,ts,jsx,tsx}');
+// };
+// module.exports = FileResolver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zohodesk/codestandard-validator",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "description": "library to enforce code standard using eslint",
   "main": "index.js",
   "scripts": {