|
const fs = require('fs');
|
const path = require('path');
|
|
const targetDir = path.resolve('e:\\AllWorkProject\\drone_project\\ztzf-drone-web\\applications\\command-center-dashboard\\src\\views\\newRoutePlan');
|
|
function getAllFiles(dirPath, arrayOfFiles) {
|
const files = fs.readdirSync(dirPath);
|
arrayOfFiles = arrayOfFiles || [];
|
|
files.forEach(function(file) {
|
if (fs.statSync(dirPath + "/" + file).isDirectory()) {
|
arrayOfFiles = getAllFiles(dirPath + "/" + file, arrayOfFiles);
|
} else {
|
if (file.endsWith('.vue') || file.endsWith('.js')) {
|
arrayOfFiles.push(path.join(dirPath, "/", file));
|
}
|
}
|
});
|
|
return arrayOfFiles;
|
}
|
|
function extractFunctions(content, filePath) {
|
const functions = [];
|
// Regex is not perfect, but good enough for finding standard definitions
|
// 1. function name(...) {
|
// 2. const name = (...) => {
|
// 3. const name = function(...) {
|
|
// We will iterate through the file to find function starts, then balance braces.
|
|
// Simple tokenizer-like approach
|
let index = 0;
|
const len = content.length;
|
|
while (index < len) {
|
// Find 'function' or 'const/let/var'
|
const sub = content.substring(index);
|
|
// Match function definition: function name (...)
|
const funcMatch = sub.match(/^(async\s+)?function\s+([a-zA-Z0-9_$]+)\s*\(/);
|
|
// Match arrow/expression: (const|let|var) name = ...
|
const varMatch = sub.match(/^(const|let|var)\s+([a-zA-Z0-9_$]+)\s*=\s*/);
|
|
if (funcMatch) {
|
const name = funcMatch[2];
|
const startBody = content.indexOf('{', index + funcMatch[0].length);
|
if (startBody !== -1) {
|
const body = extractBody(content, startBody);
|
if (body) {
|
functions.push({ name, body, filePath });
|
index = startBody + body.length;
|
continue;
|
}
|
}
|
} else if (varMatch) {
|
const name = varMatch[2];
|
// Check if it's a function assignment
|
const afterVar = index + varMatch[0].length;
|
const subAfter = content.substring(afterVar);
|
|
// Look for function(...) or (...) => or async ...
|
// This is tricky with regex.
|
// Let's simplified: if we see 'function' or '=>' closely after.
|
|
// Heuristic: Check next 100 chars for 'function' or '=>'
|
const checkLimit = Math.min(subAfter.length, 200);
|
const checkChunk = subAfter.substring(0, checkLimit);
|
|
let isFunc = false;
|
let bodyStartSearchIndex = afterVar;
|
|
if (checkChunk.match(/^\s*(async\s+)?function/)) {
|
isFunc = true;
|
} else if (checkChunk.match(/^\s*(async\s+)?\(.*?\)\s*=>/)) {
|
isFunc = true;
|
} else if (checkChunk.match(/^\s*[a-zA-Z0-9_$]+\s*=>/)) { // single arg arrow
|
isFunc = true;
|
}
|
|
if (isFunc) {
|
const startBody = content.indexOf('{', afterVar);
|
// Ensure the { is part of the function (not perfect but heuristic)
|
if (startBody !== -1 && startBody - afterVar < 200) {
|
const body = extractBody(content, startBody);
|
if (body) {
|
functions.push({ name, body, filePath });
|
index = startBody + body.length;
|
continue;
|
}
|
}
|
}
|
}
|
|
index++;
|
}
|
return functions;
|
}
|
|
function extractBody(content, startIndex) {
|
let braceCount = 0;
|
let inString = false;
|
let stringChar = '';
|
let inComment = false; // Simplified, doesn't handle block comments perfectly
|
|
for (let i = startIndex; i < content.length; i++) {
|
const char = content[i];
|
|
if (char === '{') {
|
if (!inString) braceCount++;
|
} else if (char === '}') {
|
if (!inString) {
|
braceCount--;
|
if (braceCount === 0) {
|
return content.substring(startIndex, i + 1);
|
}
|
}
|
}
|
// Handle strings/comments loosely to avoid breaking on braces inside them
|
// This is a basic parser, might fail on edge cases
|
}
|
return null;
|
}
|
|
const files = getAllFiles(targetDir);
|
const allFunctions = [];
|
|
files.forEach(file => {
|
const content = fs.readFileSync(file, 'utf8');
|
const funcs = extractFunctions(content, file);
|
allFunctions.push(...funcs);
|
});
|
|
// Find duplicates
|
// Key: name + normalized_body
|
const map = new Map();
|
|
allFunctions.forEach(f => {
|
// Normalize body: remove all whitespace
|
const normBody = f.body.replace(/\s/g, '');
|
const key = f.name + '|||' + normBody;
|
|
if (!map.has(key)) {
|
map.set(key, []);
|
}
|
map.get(key).push(f.filePath);
|
});
|
|
console.log("Checking for duplicates...");
|
let found = false;
|
map.forEach((paths, key) => {
|
if (paths.length > 1) {
|
// Check if paths are actually different (ignore same file if scanned twice? No, unique files)
|
// Actually user wants "identical name, identical body".
|
// Check if the file paths are distinct
|
const uniquePaths = [...new Set(paths)];
|
|
if (uniquePaths.length > 1) {
|
const name = key.split('|||')[0];
|
if (name && name !== 'setup' && name !== 'data') { // Ignore common Vue boilerplate if any
|
console.log(`\nDuplicate Function: ${name}`);
|
uniquePaths.forEach(p => console.log(` - ${p}`));
|
found = true;
|
}
|
}
|
}
|
});
|
|
if (!found) {
|
console.log("No duplicates found.");
|
}
|
