37a6183eb4
Fix VS Code extension storage paths for new directory structure Fix jqhtml compiled files missing from bundle Fix bundle babel transformation and add rsxrealpath() function 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
378 lines
18 KiB
JavaScript
Executable File
378 lines
18 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
/**
|
|
* JavaScript 'this' usage parser for code quality checks
|
|
*
|
|
* PURPOSE: Parse JavaScript files to find 'this' usage violations
|
|
* according to RSpade coding standards.
|
|
*
|
|
* USAGE: node this-usage-parser.js <filepath>
|
|
* OUTPUT: JSON with violations array
|
|
*
|
|
* RULES:
|
|
* - Anonymous functions can use: const $var = $(this) as first line
|
|
* - Instance methods must use: const that = this as first line
|
|
* - Static methods should never use 'this', use ClassName instead
|
|
* - Arrow functions are ignored (they inherit 'this')
|
|
*
|
|
* @FILENAME-CONVENTION-EXCEPTION - Node.js utility script
|
|
*/
|
|
|
|
const fs = require('fs');
|
|
const acorn = require('acorn');
|
|
const walk = require('acorn-walk');
|
|
|
|
// Known jQuery callback methods - used for better remediation messages
|
|
const JQUERY_CALLBACKS = new Set([
|
|
'click', 'dblclick', 'mouseenter', 'mouseleave', 'mousedown', 'mouseup',
|
|
'mousemove', 'mouseover', 'mouseout', 'change', 'submit', 'focus', 'blur',
|
|
'keydown', 'keyup', 'keypress', 'resize', 'scroll', 'select', 'load',
|
|
'on', 'off', 'one', 'each', 'map', 'filter',
|
|
'fadeIn', 'fadeOut', 'slideDown', 'slideUp', 'animate',
|
|
'done', 'fail', 'always', 'then', 'ready', 'hover'
|
|
]);
|
|
|
|
function analyzeFile(filePath) {
|
|
try {
|
|
const code = fs.readFileSync(filePath, 'utf8');
|
|
const lines = code.split('\n');
|
|
|
|
let ast;
|
|
try {
|
|
ast = acorn.parse(code, {
|
|
ecmaVersion: 2020,
|
|
sourceType: 'module',
|
|
locations: true
|
|
});
|
|
} catch (e) {
|
|
// Parse error - return empty violations
|
|
return { violations: [], error: `Parse error: ${e.message}` };
|
|
}
|
|
|
|
const violations = [];
|
|
const classInfo = new Map(); // Track class info
|
|
|
|
// First pass: identify all classes and their types
|
|
walk.simple(ast, {
|
|
ClassDeclaration(node) {
|
|
const hasStaticInit = node.body.body.some(member =>
|
|
member.static && member.key?.name === 'init'
|
|
);
|
|
classInfo.set(node.id.name, {
|
|
isStatic: hasStaticInit
|
|
});
|
|
}
|
|
});
|
|
|
|
// Helper to check if first line of function has valid pattern
|
|
function checkFirstLinePattern(funcNode) {
|
|
if (!funcNode.body || !funcNode.body.body || funcNode.body.body.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
let checkIndex = 0;
|
|
const firstStmt = funcNode.body.body[0];
|
|
|
|
// Check if first statement is e.preventDefault() or similar
|
|
if (firstStmt.type === 'ExpressionStatement' &&
|
|
firstStmt.expression?.type === 'CallExpression' &&
|
|
firstStmt.expression?.callee?.type === 'MemberExpression' &&
|
|
firstStmt.expression?.callee?.property?.name === 'preventDefault') {
|
|
// First line is preventDefault, check second line for pattern
|
|
checkIndex = 1;
|
|
if (funcNode.body.body.length <= 1) {
|
|
return null; // No second statement
|
|
}
|
|
}
|
|
|
|
const targetStmt = funcNode.body.body[checkIndex];
|
|
if (targetStmt.type !== 'VariableDeclaration') {
|
|
return null;
|
|
}
|
|
|
|
const firstDecl = targetStmt.declarations[0];
|
|
if (!firstDecl || !firstDecl.init) {
|
|
return null;
|
|
}
|
|
|
|
const varKind = targetStmt.kind; // 'const', 'let', or 'var'
|
|
|
|
// Check for 'that = this' pattern
|
|
if (firstDecl.id.name === 'that' &&
|
|
firstDecl.init.type === 'ThisExpression') {
|
|
if (varKind !== 'const') {
|
|
return 'that-pattern-wrong-kind';
|
|
}
|
|
return 'that-pattern';
|
|
}
|
|
|
|
// Check for 'CurrentClass = this' pattern (for static polymorphism)
|
|
if (firstDecl.id.name === 'CurrentClass' &&
|
|
firstDecl.init.type === 'ThisExpression') {
|
|
if (varKind !== 'const') {
|
|
return 'currentclass-pattern-wrong-kind';
|
|
}
|
|
return 'currentclass-pattern';
|
|
}
|
|
|
|
// Check for '$var = $(this)' pattern
|
|
if (firstDecl.id.name.startsWith('$') &&
|
|
firstDecl.init.type === 'CallExpression' &&
|
|
firstDecl.init.callee.name === '$' &&
|
|
firstDecl.init.arguments.length === 1 &&
|
|
firstDecl.init.arguments[0].type === 'ThisExpression') {
|
|
if (varKind !== 'const') {
|
|
return 'jquery-pattern-wrong-kind';
|
|
}
|
|
return 'jquery-pattern';
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
// Helper to detect if we're in a jQuery callback (best effort)
|
|
function isLikelyJQueryCallback(ancestors) {
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
const node = ancestors[i];
|
|
if (node.type === 'CallExpression' && node.callee.type === 'MemberExpression') {
|
|
const methodName = node.callee.property.name;
|
|
if (JQUERY_CALLBACKS.has(methodName)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Walk the AST looking for 'this' usage
|
|
walk.ancestor(ast, {
|
|
ThisExpression(node, ancestors) {
|
|
// Skip arrow functions - they inherit 'this'
|
|
for (const ancestor of ancestors) {
|
|
if (ancestor.type === 'ArrowFunctionExpression') {
|
|
return; // Skip - arrow functions inherit context
|
|
}
|
|
}
|
|
|
|
// Find containing function and class
|
|
let containingFunc = null;
|
|
let containingClass = null;
|
|
let isAnonymousFunc = false;
|
|
let isStaticMethod = false;
|
|
let isConstructor = false;
|
|
let isInstanceMethod = false;
|
|
let hasMethodDefinition = false;
|
|
|
|
// First pass: check if we're in a MethodDefinition
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
const ancestor = ancestors[i];
|
|
if (ancestor.type === 'MethodDefinition') {
|
|
hasMethodDefinition = true;
|
|
isStaticMethod = ancestor.static;
|
|
isConstructor = ancestor.kind === 'constructor';
|
|
isInstanceMethod = !ancestor.static && ancestor.kind !== 'constructor';
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Second pass: find function and class
|
|
for (let i = ancestors.length - 1; i >= 0; i--) {
|
|
const ancestor = ancestors[i];
|
|
|
|
if (!containingFunc && (
|
|
ancestor.type === 'FunctionExpression' ||
|
|
ancestor.type === 'FunctionDeclaration'
|
|
)) {
|
|
containingFunc = ancestor;
|
|
// Only mark as anonymous if NOT inside a MethodDefinition
|
|
isAnonymousFunc = ancestor.type === 'FunctionExpression' && !hasMethodDefinition;
|
|
}
|
|
|
|
if (!containingClass && (
|
|
ancestor.type === 'ClassDeclaration' ||
|
|
ancestor.type === 'ClassExpression'
|
|
)) {
|
|
containingClass = ancestor;
|
|
}
|
|
}
|
|
|
|
if (!containingFunc) {
|
|
return; // Not in a function
|
|
}
|
|
|
|
// Skip constructors - 'this' is allowed for property assignment
|
|
if (isConstructor) {
|
|
return;
|
|
}
|
|
|
|
// Skip instance methods - 'this' is allowed directly in instance methods
|
|
// Only enforce aliasing for anonymous functions and static methods
|
|
if (isInstanceMethod) {
|
|
return;
|
|
}
|
|
|
|
// Check if this is part of the allowed first-line pattern with const
|
|
const parent = ancestors[ancestors.length - 2];
|
|
const firstStmt = containingFunc.body?.body?.[0];
|
|
let checkIndex = 0;
|
|
|
|
// Check if first statement is preventDefault
|
|
const hasPreventDefault = firstStmt?.type === 'ExpressionStatement' &&
|
|
firstStmt?.expression?.type === 'CallExpression' &&
|
|
firstStmt?.expression?.callee?.type === 'MemberExpression' &&
|
|
firstStmt?.expression?.callee?.property?.name === 'preventDefault';
|
|
|
|
if (hasPreventDefault) {
|
|
checkIndex = 1;
|
|
}
|
|
|
|
const targetStmt = containingFunc.body?.body?.[checkIndex];
|
|
const isTargetConst = targetStmt?.type === 'VariableDeclaration' && targetStmt?.kind === 'const';
|
|
|
|
// Check if this 'this' is inside $(this) on the first or second line
|
|
// For jQuery pattern: const $var = $(this)
|
|
if (parent && parent.type === 'CallExpression' && parent.callee?.name === '$') {
|
|
// This is $(this) - check if it's in the right position with const
|
|
if (isTargetConst &&
|
|
targetStmt?.declarations?.[0]?.init === parent &&
|
|
targetStmt?.declarations?.[0]?.id?.name?.startsWith('$')) {
|
|
return; // This is const $var = $(this) in correct position
|
|
}
|
|
}
|
|
|
|
// Check if this 'this' is the 'const that = this' in correct position
|
|
if (parent && parent.type === 'VariableDeclarator' &&
|
|
parent.id?.name === 'that' &&
|
|
isTargetConst &&
|
|
targetStmt?.declarations?.[0]?.id?.name === 'that') {
|
|
return; // This is 'const that = this' in correct position
|
|
}
|
|
|
|
// Check if this 'this' is the 'const CurrentClass = this' in correct position
|
|
if (parent && parent.type === 'VariableDeclarator' &&
|
|
parent.id?.name === 'CurrentClass' &&
|
|
isTargetConst &&
|
|
targetStmt?.declarations?.[0]?.id?.name === 'CurrentClass') {
|
|
return; // This is 'const CurrentClass = this' in correct position
|
|
}
|
|
|
|
// Check what pattern is used
|
|
const pattern = checkFirstLinePattern(containingFunc);
|
|
|
|
// Determine the violation and remediation
|
|
let message = '';
|
|
let remediation = '';
|
|
const lineNum = node.loc.start.line;
|
|
const codeSnippet = lines[lineNum - 1].trim();
|
|
const className = containingClass?.id?.name || 'unknown';
|
|
const isJQueryContext = isLikelyJQueryCallback(ancestors);
|
|
|
|
// Anonymous functions take precedence - even if inside a static method
|
|
if (isAnonymousFunc) {
|
|
if (!pattern) {
|
|
// Check if there's a preventDefault on the first line
|
|
const firstStmt = containingFunc.body?.body?.[0];
|
|
const hasPreventDefault = firstStmt?.type === 'ExpressionStatement' &&
|
|
firstStmt?.expression?.type === 'CallExpression' &&
|
|
firstStmt?.expression?.callee?.type === 'MemberExpression' &&
|
|
firstStmt?.expression?.callee?.property?.name === 'preventDefault';
|
|
|
|
if (isJQueryContext) {
|
|
message = `'this' in jQuery callback should be aliased for clarity.`;
|
|
if (hasPreventDefault) {
|
|
remediation = `Add 'const $element = $(this);' as the second line (after preventDefault), then use $element instead of 'this'.`;
|
|
} else {
|
|
remediation = `Add 'const $element = $(this);' as the first line of this function, then use $element instead of 'this'.`;
|
|
}
|
|
} else {
|
|
message = `Ambiguous 'this' usage in anonymous function.`;
|
|
if (hasPreventDefault) {
|
|
remediation = `If this is a jQuery callback: Add 'const $element = $(this);' as the second line (after preventDefault).\n` +
|
|
`If this is an instance context: Add 'const that = this;' as the second line.\n` +
|
|
`Then use the aliased variable instead of 'this'.`;
|
|
} else {
|
|
remediation = `If this is a jQuery callback: Add 'const $element = $(this);' as first line.\n` +
|
|
`If this is an instance context: Add 'const that = this;' as first line.\n` +
|
|
`Then use the aliased variable instead of 'this'.`;
|
|
}
|
|
}
|
|
} else if (pattern === 'that-pattern' || pattern === 'jquery-pattern') {
|
|
message = `'this' used after aliasing. Use the aliased variable instead.`;
|
|
// Find the variable declaration (might be first or second statement)
|
|
let varDeclIndex = 0;
|
|
const firstStmt = containingFunc.body?.body?.[0];
|
|
if (firstStmt?.type === 'ExpressionStatement' &&
|
|
firstStmt?.expression?.callee?.property?.name === 'preventDefault') {
|
|
varDeclIndex = 1;
|
|
}
|
|
const varName = containingFunc.body?.body?.[varDeclIndex]?.declarations?.[0]?.id?.name;
|
|
remediation = pattern === 'jquery-pattern'
|
|
? `You already have 'const ${varName} = $(this)'. Use that variable instead of 'this'.`
|
|
: `You already have 'const that = this'. Use 'that' instead of 'this'.`;
|
|
} else if (pattern === 'that-pattern-wrong-kind') {
|
|
message = `Instance alias must use 'const', not 'let' or 'var'.`;
|
|
remediation = `Change to 'const that = this;' - the instance reference should never be reassigned.`;
|
|
} else if (pattern === 'jquery-pattern-wrong-kind') {
|
|
message = `jQuery element alias must use 'const', not 'let' or 'var'.`;
|
|
remediation = `Change to 'const $element = $(this);' - jQuery element references should never be reassigned.`;
|
|
}
|
|
} else if (isStaticMethod) {
|
|
if (!pattern) {
|
|
message = `Static method in '${className}' should not use naked 'this'.`;
|
|
remediation = `Static methods have two options:\n` +
|
|
`1. If you need the exact class (no polymorphism): Replace 'this' with '${className}'\n` +
|
|
`2. If you need polymorphism (inherited classes): Add 'const CurrentClass = this;' as first line\n` +
|
|
` Then use CurrentClass.name or CurrentClass.property for polymorphic access.\n` +
|
|
`Consider: Does this.name need to work for child classes? If yes, use CurrentClass pattern.`;
|
|
} else if (pattern === 'currentclass-pattern') {
|
|
message = `'this' used after aliasing to CurrentClass. Use 'CurrentClass' instead.`;
|
|
remediation = `You already have 'const CurrentClass = this;'. Use 'CurrentClass' for all access, not naked 'this'.`;
|
|
} else if (pattern === 'currentclass-pattern-wrong-kind') {
|
|
message = `CurrentClass pattern must use 'const', not 'let' or 'var'.`;
|
|
remediation = `Change to 'const CurrentClass = this;' - the CurrentClass reference should never be reassigned.`;
|
|
} else if (pattern === 'jquery-pattern') {
|
|
// jQuery pattern in static method's anonymous function is OK
|
|
return;
|
|
} else if (pattern === 'jquery-pattern-wrong-kind') {
|
|
message = `jQuery element alias must use 'const', not 'let' or 'var'.`;
|
|
remediation = `Change to 'const $element = $(this);' - jQuery element references should never be reassigned.`;
|
|
}
|
|
|
|
if (isAnonymousFunc && !pattern) {
|
|
remediation += `\nException: If this is a jQuery callback, add 'const $element = $(this);' as the first line.`;
|
|
}
|
|
}
|
|
// NOTE: Instance methods are exempt from this rule - they can use 'this' directly
|
|
// The check returns early for instance methods, so this else block is unreachable for them
|
|
|
|
if (message) {
|
|
violations.push({
|
|
line: lineNum,
|
|
message: message,
|
|
codeSnippet: codeSnippet,
|
|
remediation: remediation
|
|
});
|
|
}
|
|
}
|
|
});
|
|
|
|
return { violations: violations };
|
|
|
|
} catch (error) {
|
|
return { violations: [], error: error.message };
|
|
}
|
|
}
|
|
|
|
// Main execution
|
|
const filePath = process.argv[2];
|
|
if (!filePath) {
|
|
console.log(JSON.stringify({ violations: [], error: 'No file path provided' }));
|
|
process.exit(1);
|
|
}
|
|
|
|
if (!fs.existsSync(filePath)) {
|
|
console.log(JSON.stringify({ violations: [], error: `File not found: ${filePath}` }));
|
|
process.exit(1);
|
|
}
|
|
|
|
const result = analyzeFile(filePath);
|
|
console.log(JSON.stringify(result)); |