react-code-smell-detector 1.2.0 → 1.3.1

package/src/analyzer.ts

@@ -1,324 +0,0 @@
-import fg from 'fast-glob';
-import path from 'path';
-import { parseFile, ParseResult } from './parser/index.js';
-import {
-  detectUseEffectOveruse,
-  detectPropDrilling,
-  analyzePropDrillingDepth,
-  detectLargeComponent,
-  detectUnmemoizedCalculations,
-  detectMissingKeys,
-  detectHooksRulesViolations,
-  detectDependencyArrayIssues,
-  detectNestedTernaries,
-  detectDeadCode,
-  detectMagicValues,
-  detectNextjsIssues,
-  detectReactNativeIssues,
-  detectNodejsIssues,
-  detectJavascriptIssues,
-  detectTypescriptIssues,
-  detectDebugStatements,
-  detectSecurityIssues,
-  detectAccessibilityIssues,
-} from './detectors/index.js';
-import {
-  AnalysisResult,
-  FileAnalysis,
-  ComponentInfo,
-  CodeSmell,
-  AnalysisSummary,
-  TechnicalDebtScore,
-  DetectorConfig,
-  DEFAULT_CONFIG,
-  SmellType,
-  SmellSeverity,
-} from './types/index.js';
-
-export interface AnalyzerOptions {
-  rootDir: string;
-  include?: string[];
-  exclude?: string[];
-  config?: Partial<DetectorConfig>;
-}
-
-export async function analyzeProject(options: AnalyzerOptions): Promise<AnalysisResult> {
-  const {
-    rootDir,
-    include = ['**/*.tsx', '**/*.jsx'],
-    exclude = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/*.test.*', '**/*.spec.*'],
-    config: userConfig = {},
-  } = options;
-
-  const config: DetectorConfig = { ...DEFAULT_CONFIG, ...userConfig };
-
-  // Find all React files
-  const patterns = include.map(p => path.join(rootDir, p));
-  const files = await fg(patterns, {
-    ignore: exclude,
-    absolute: true,
-  });
-
-  const fileAnalyses: FileAnalysis[] = [];
-
-  // Analyze each file
-  for (const file of files) {
-    try {
-      const parseResult = await parseFile(file);
-      const analysis = analyzeFile(parseResult, file, config);
-      if (analysis.components.length > 0 || analysis.smells.length > 0) {
-        fileAnalyses.push(analysis);
-      }
-    } catch (error) {
-      // Skip files that can't be parsed
-      console.warn(`Warning: Could not parse ${file}: ${(error as Error).message}`);
-    }
-  }
-
-  // Calculate summary and score
-  const summary = calculateSummary(fileAnalyses);
-  const debtScore = calculateTechnicalDebtScore(fileAnalyses, summary);
-
-  return {
-    files: fileAnalyses,
-    summary,
-    debtScore,
-  };
-}
-
-function analyzeFile(parseResult: ParseResult, filePath: string, config: DetectorConfig): FileAnalysis {
-  const { components, imports, sourceCode } = parseResult;
-  const smells: CodeSmell[] = [];
-  const componentInfos: ComponentInfo[] = [];
-
-  // Run all detectors on each component
-  components.forEach(component => {
-    // Collect component info
-    componentInfos.push({
-      name: component.name,
-      file: filePath,
-      startLine: component.startLine,
-      endLine: component.endLine,
-      lineCount: component.endLine - component.startLine + 1,
-      useEffectCount: component.hooks.useEffect.length,
-      useStateCount: component.hooks.useState.length,
-      useMemoCount: component.hooks.useMemo.length,
-      useCallbackCount: component.hooks.useCallback.length,
-      propsCount: component.props.length,
-      propsDrillingDepth: 0, // Calculated separately
-      hasExpensiveCalculation: false, // Will be set by memoization detector
-    });
-
-    // Run detectors
-    smells.push(...detectUseEffectOveruse(component, filePath, sourceCode, config));
-    smells.push(...detectPropDrilling(component, filePath, sourceCode, config));
-    smells.push(...detectLargeComponent(component, filePath, sourceCode, config));
-    smells.push(...detectUnmemoizedCalculations(component, filePath, sourceCode, config));
-    smells.push(...detectMissingKeys(component, filePath, sourceCode, config));
-    smells.push(...detectHooksRulesViolations(component, filePath, sourceCode, config));
-    smells.push(...detectDependencyArrayIssues(component, filePath, sourceCode, config));
-    smells.push(...detectNestedTernaries(component, filePath, sourceCode, config));
-    smells.push(...detectDeadCode(component, filePath, sourceCode, config));
-    smells.push(...detectMagicValues(component, filePath, sourceCode, config));
-    // Framework-specific detectors
-    smells.push(...detectNextjsIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectReactNativeIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectNodejsIssues(component, filePath, sourceCode, config, imports));
-    smells.push(...detectJavascriptIssues(component, filePath, sourceCode, config));
-    smells.push(...detectTypescriptIssues(component, filePath, sourceCode, config));
-    // Debug, Security, Accessibility
-    smells.push(...detectDebugStatements(component, filePath, sourceCode, config));
-    smells.push(...detectSecurityIssues(component, filePath, sourceCode, config));
-    smells.push(...detectAccessibilityIssues(component, filePath, sourceCode, config));
-  });
-
-  // Run cross-component analysis
-  smells.push(...analyzePropDrillingDepth(components, filePath, sourceCode, config));
-
-  // Filter out smells with @smell-ignore comments
-  const filteredSmells = filterIgnoredSmells(smells, sourceCode);
-
-  return {
-    file: filePath,
-    components: componentInfos,
-    smells: filteredSmells,
-    imports,
-  };
-}
-
-/**
- * Filter out smells that have @smell-ignore comment on the preceding line
- * Supports: // @smell-ignore, block comments with @smell-ignore, @smell-ignore [type]
- */
-function filterIgnoredSmells(smells: CodeSmell[], sourceCode: string): CodeSmell[] {
-  const lines = sourceCode.split('\n');
-  
-  return smells.filter(smell => {
-    if (smell.line <= 1) return true;
-    
-    // Check the line before and the same line for ignore comments
-    const lineIndex = smell.line - 1; // Convert to 0-indexed
-    const prevLine = lines[lineIndex - 1]?.trim() || '';
-    const currentLine = lines[lineIndex]?.trim() || '';
-    
-    // Check for @smell-ignore patterns
-    const ignorePatterns = [
-      /@smell-ignore\s*$/,                           // @smell-ignore (ignore all)
-      /@smell-ignore\s+\*/,                          // @smell-ignore * (ignore all)
-      new RegExp(`@smell-ignore\\s+${smell.type}`),  // @smell-ignore [specific-type]
-    ];
-    
-    for (const pattern of ignorePatterns) {
-      if (pattern.test(prevLine) || pattern.test(currentLine)) {
-        return false; // Filter out this smell
-      }
-    }
-    
-    return true; // Keep this smell
-  });
-}
-
-function calculateSummary(files: FileAnalysis[]): AnalysisSummary {
-  const smellsByType: Record<SmellType, number> = {
-    'useEffect-overuse': 0,
-    'prop-drilling': 0,
-    'large-component': 0,
-    'unmemoized-calculation': 0,
-    'missing-dependency': 0,
-    'state-in-loop': 0,
-    'inline-function-prop': 0,
-    'deep-nesting': 0,
-    'missing-key': 0,
-    'hooks-rules-violation': 0,
-    'dependency-array-issue': 0,
-    'nested-ternary': 0,
-    'dead-code': 0,
-    'magic-value': 0,
-    // Next.js
-    'nextjs-client-server-boundary': 0,
-    'nextjs-missing-metadata': 0,
-    'nextjs-image-unoptimized': 0,
-    'nextjs-router-misuse': 0,
-    // React Native
-    'rn-inline-style': 0,
-    'rn-missing-accessibility': 0,
-    'rn-performance-issue': 0,
-    // Node.js
-    'nodejs-callback-hell': 0,
-    'nodejs-unhandled-promise': 0,
-    'nodejs-sync-io': 0,
-    'nodejs-missing-error-handling': 0,
-    // JavaScript
-    'js-var-usage': 0,
-    'js-loose-equality': 0,
-    'js-implicit-coercion': 0,
-    'js-global-pollution': 0,
-    // TypeScript
-    'ts-any-usage': 0,
-    'ts-missing-return-type': 0,
-    'ts-non-null-assertion': 0,
-    'ts-type-assertion': 0,
-    // Debug statements
-    'debug-statement': 0,
-    'todo-comment': 0,
-    // Security
-    'security-xss': 0,
-    'security-eval': 0,
-    'security-secrets': 0,
-    // Accessibility
-    'a11y-missing-alt': 0,
-    'a11y-missing-label': 0,
-    'a11y-interactive-role': 0,
-    'a11y-keyboard': 0,
-    'a11y-semantic': 0,
-  };
-
-  const smellsBySeverity: Record<SmellSeverity, number> = {
-    error: 0,
-    warning: 0,
-    info: 0,
-  };
-
-  let totalSmells = 0;
-  let totalComponents = 0;
-
-  files.forEach(file => {
-    totalComponents += file.components.length;
-    file.smells.forEach(smell => {
-      totalSmells++;
-      smellsByType[smell.type]++;
-      smellsBySeverity[smell.severity]++;
-    });
-  });
-
-  return {
-    totalFiles: files.length,
-    totalComponents,
-    totalSmells,
-    smellsByType,
-    smellsBySeverity,
-  };
-}
-
-function calculateTechnicalDebtScore(files: FileAnalysis[], summary: AnalysisSummary): TechnicalDebtScore {
-  // Calculate individual scores (0-100, higher is better)
-  
-  // useEffect score: penalize based on useEffect-related issues
-  const useEffectIssues = summary.smellsByType['useEffect-overuse'];
-  const useEffectScore = Math.max(0, 100 - useEffectIssues * 15);
-
-  // Prop drilling score
-  const propDrillingIssues = summary.smellsByType['prop-drilling'];
-  const propDrillingScore = Math.max(0, 100 - propDrillingIssues * 12);
-
-  // Component size score
-  const sizeIssues = summary.smellsByType['large-component'] + summary.smellsByType['deep-nesting'];
-  const componentSizeScore = Math.max(0, 100 - sizeIssues * 10);
-
-  // Memoization score
-  const memoIssues = summary.smellsByType['unmemoized-calculation'] + summary.smellsByType['inline-function-prop'];
-  const memoizationScore = Math.max(0, 100 - memoIssues * 8);
-
-  // Overall score (weighted average)
-  const score = Math.round(
-    useEffectScore * 0.3 +
-    propDrillingScore * 0.25 +
-    componentSizeScore * 0.25 +
-    memoizationScore * 0.2
-  );
-
-  // Determine grade
-  let grade: 'A' | 'B' | 'C' | 'D' | 'F';
-  if (score >= 90) grade = 'A';
-  else if (score >= 80) grade = 'B';
-  else if (score >= 70) grade = 'C';
-  else if (score >= 60) grade = 'D';
-  else grade = 'F';
-
-  // Estimate refactor time
-  const errorCount = summary.smellsBySeverity.error;
-  const warningCount = summary.smellsBySeverity.warning;
-  const totalIssues = errorCount * 30 + warningCount * 15; // minutes
-  
-  let estimatedRefactorTime: string;
-  if (totalIssues < 30) estimatedRefactorTime = '< 30 minutes';
-  else if (totalIssues < 60) estimatedRefactorTime = '30 min - 1 hour';
-  else if (totalIssues < 120) estimatedRefactorTime = '1-2 hours';
-  else if (totalIssues < 240) estimatedRefactorTime = '2-4 hours';
-  else if (totalIssues < 480) estimatedRefactorTime = '4-8 hours';
-  else estimatedRefactorTime = '> 1 day';
-
-  return {
-    score,
-    grade,
-    breakdown: {
-      useEffectScore,
-      propDrillingScore,
-      componentSizeScore,
-      memoizationScore,
-    },
-    estimatedRefactorTime,
-  };
-}
-
-export { DEFAULT_CONFIG, DetectorConfig } from './types/index.js';

package/src/cli.ts

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import path from 'path';
-import { analyzeProject, DEFAULT_CONFIG } from './analyzer.js';
-import { reportResults } from './reporter.js';
-import { generateHTMLReport } from './htmlReporter.js';
-import fs from 'fs/promises';
-
-const program = new Command();
-
-program
-  .name('react-smell')
-  .description('Detect code smells in React projects')
-  .version('1.2.0')
-  .argument('[directory]', 'Directory to analyze', '.')
-  .option('-f, --format <format>', 'Output format: console, json, markdown, html', 'console')
-  .option('-s, --snippets', 'Show code snippets in output', false)
-  .option('-c, --config <file>', 'Path to config file')
-  .option('--ci', 'CI mode: exit with code 1 if any issues found')
-  .option('--fail-on <severity>', 'Exit with code 1 if issues of this severity or higher (error, warning, info)', 'error')
-  .option('--max-effects <number>', 'Max useEffects per component', parseInt)
-  .option('--max-props <number>', 'Max props before warning', parseInt)
-  .option('--max-lines <number>', 'Max lines per component', parseInt)
-  .option('--include <patterns>', 'Glob patterns to include (comma-separated)')
-  .option('--exclude <patterns>', 'Glob patterns to exclude (comma-separated)')
-  .option('-o, --output <file>', 'Write output to file')
-  .action(async (directory, options) => {
-    const rootDir = path.resolve(process.cwd(), directory);
-    
-    // Check if directory exists
-    try {
-      await fs.access(rootDir);
-    } catch {
-      console.error(chalk.red(`Error: Directory "${rootDir}" does not exist.`));
-      process.exit(1);
-    }
-
-    const spinner = ora('Analyzing React project...').start();
-
-    try {
-      // Load config file if specified
-      let fileConfig = {};
-      if (options.config) {
-        try {
-          const configPath = path.resolve(process.cwd(), options.config);
-          const configContent = await fs.readFile(configPath, 'utf-8');
-          fileConfig = JSON.parse(configContent);
-        } catch (error) {
-          spinner.fail(`Could not load config file: ${(error as Error).message}`);
-          process.exit(1);
-        }
-      }
-
-      // Build config from options
-      const config = {
-        ...DEFAULT_CONFIG,
-        ...fileConfig,
-        ...(options.maxEffects && { maxUseEffectsPerComponent: options.maxEffects }),
-        ...(options.maxProps && { maxPropsCount: options.maxProps }),
-        ...(options.maxLines && { maxComponentLines: options.maxLines }),
-      };
-
-      const include = options.include?.split(',').map((p: string) => p.trim()) || undefined;
-      const exclude = options.exclude?.split(',').map((p: string) => p.trim()) || undefined;
-
-      const result = await analyzeProject({
-        rootDir,
-        include,
-        exclude,
-        config,
-      });
-
-      spinner.stop();
-
-      let output: string;
-      if (options.format === 'html') {
-        output = generateHTMLReport(result, rootDir);
-        // Auto-set output file for HTML if not specified
-        if (!options.output) {
-          options.output = 'code-smell-report.html';
-        }
-      } else {
-        output = reportResults(result, {
-          format: options.format,
-          showCodeSnippets: options.snippets,
-          rootDir,
-        });
-      }
-
-      if (options.output) {
-        const outputPath = path.resolve(process.cwd(), options.output);
-        await fs.writeFile(outputPath, output, 'utf-8');
-        console.log(chalk.green(`✓ Report written to ${outputPath}`));
-      } else {
-        console.log(output);
-      }
-
-      // CI/CD exit code handling
-      const { smellsBySeverity } = result.summary;
-      let shouldFail = false;
-
-      if (options.ci) {
-        // CI mode: fail on any issues
-        shouldFail = result.summary.totalSmells > 0;
-      } else {
-        // Check fail-on threshold
-        switch (options.failOn) {
-          case 'info':
-            shouldFail = smellsBySeverity.info > 0 || smellsBySeverity.warning > 0 || smellsBySeverity.error > 0;
-            break;
-          case 'warning':
-            shouldFail = smellsBySeverity.warning > 0 || smellsBySeverity.error > 0;
-            break;
-          case 'error':
-          default:
-            shouldFail = smellsBySeverity.error > 0;
-            break;
-        }
-      }
-
-      if (shouldFail) {
-        process.exit(1);
-      }
-    } catch (error) {
-      spinner.fail(`Analysis failed: ${(error as Error).message}`);
-      if (process.env.DEBUG) {
-        console.error(error);
-      }
-      process.exit(1);
-    }
-  });
-
-// Init command to create config file
-program
-  .command('init')
-  .description('Create a configuration file')
-  .action(async () => {
-    const configContent = JSON.stringify({
-      maxUseEffectsPerComponent: DEFAULT_CONFIG.maxUseEffectsPerComponent,
-      maxPropDrillingDepth: DEFAULT_CONFIG.maxPropDrillingDepth,
-      maxComponentLines: DEFAULT_CONFIG.maxComponentLines,
-      maxPropsCount: DEFAULT_CONFIG.maxPropsCount,
-    }, null, 2);
-
-    const configPath = path.join(process.cwd(), '.smellrc.json');
-    
-    try {
-      await fs.access(configPath);
-      console.log(chalk.yellow('Config file already exists at .smellrc.json'));
-    } catch {
-      await fs.writeFile(configPath, configContent, 'utf-8');
-      console.log(chalk.green('✓ Created .smellrc.json'));
-    }
-  });
-
-program.parse();

package/src/detectors/accessibility.ts

@@ -1,212 +0,0 @@
-import * as t from '@babel/types';
-import { ParsedComponent, getCodeSnippet } from '../parser/index.js';
-import { CodeSmell, DetectorConfig, DEFAULT_CONFIG } from '../types/index.js';
-
-/**
- * Detects accessibility (a11y) issues:
- * - Images without alt text
- * - Form inputs without labels
- * - Missing ARIA attributes on interactive elements
- * - Click handlers without keyboard support
- * - Improper heading hierarchy
- */
-export function detectAccessibilityIssues(
-  component: ParsedComponent,
-  filePath: string,
-  sourceCode: string,
-  config: DetectorConfig = DEFAULT_CONFIG
-): CodeSmell[] {
-  if (!config.checkAccessibility) return [];
-
-  const smells: CodeSmell[] = [];
-
-  component.path.traverse({
-    JSXOpeningElement(path) {
-      if (!t.isJSXIdentifier(path.node.name)) return;
-      
-      const elementName = path.node.name.name;
-      const attributes = path.node.attributes;
-      const loc = path.node.loc;
-      const line = loc?.start.line || 0;
-
-      // Helper to check if attribute exists
-      const hasAttr = (name: string): boolean => {
-        return attributes.some(attr => {
-          if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name)) {
-            return attr.name.name === name;
-          }
-          // Handle spread attributes - assume they might contain the attribute
-          return t.isJSXSpreadAttribute(attr);
-        });
-      };
-
-      // Helper to get attribute value
-      const getAttrValue = (name: string): string | null => {
-        for (const attr of attributes) {
-          if (t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name) && attr.name.name === name) {
-            if (t.isStringLiteral(attr.value)) {
-              return attr.value.value;
-            }
-          }
-        }
-        return null;
-      };
-
-      // Check for images without alt text
-      if (elementName === 'img') {
-        if (!hasAttr('alt')) {
-          smells.push({
-            type: 'a11y-missing-alt',
-            severity: 'error',
-            message: `<img> missing alt attribute in "${component.name}"`,
-            file: filePath,
-            line,
-            column: loc?.start.column || 0,
-            suggestion: 'Add alt="description" for content images, or alt="" for decorative images',
-            codeSnippet: getCodeSnippet(sourceCode, line),
-          });
-        } else {
-          const altValue = getAttrValue('alt');
-          if (altValue !== null && altValue.toLowerCase().includes('image')) {
-            smells.push({
-              type: 'a11y-missing-alt',
-              severity: 'info',
-              message: `<img> alt text shouldn't contain "image" - it's redundant`,
-              file: filePath,
-              line,
-              column: loc?.start.column || 0,
-              suggestion: 'Describe what the image shows, not that it is an image',
-              codeSnippet: getCodeSnippet(sourceCode, line),
-            });
-          }
-        }
-      }
-
-      // Check for form inputs without associated labels
-      if (elementName === 'input' || elementName === 'textarea' || elementName === 'select') {
-        const inputType = getAttrValue('type') || 'text';
-        
-        // Skip hidden inputs
-        if (inputType === 'hidden') return;
-        
-        const hasLabel = hasAttr('aria-label') || 
-                        hasAttr('aria-labelledby') || 
-                        hasAttr('id'); // Assume id might be linked to a label
-        
-        if (!hasLabel) {
-          smells.push({
-            type: 'a11y-missing-label',
-            severity: 'warning',
-            message: `<${elementName}> without accessible label in "${component.name}"`,
-            file: filePath,
-            line,
-            column: loc?.start.column || 0,
-            suggestion: 'Add aria-label, aria-labelledby, or associate with a <label> element',
-            codeSnippet: getCodeSnippet(sourceCode, line),
-          });
-        }
-      }
-
-      // Check for interactive divs/spans without proper role and keyboard support
-      if (elementName === 'div' || elementName === 'span') {
-        const hasOnClick = hasAttr('onClick');
-        const hasRole = hasAttr('role');
-        const hasTabIndex = hasAttr('tabIndex');
-        const hasKeyboardHandler = hasAttr('onKeyDown') || hasAttr('onKeyUp') || hasAttr('onKeyPress');
-
-        if (hasOnClick) {
-          if (!hasRole) {
-            smells.push({
-              type: 'a11y-interactive-role',
-              severity: 'warning',
-              message: `Clickable <${elementName}> without role attribute in "${component.name}"`,
-              file: filePath,
-              line,
-              column: loc?.start.column || 0,
-              suggestion: 'Add role="button" or use a <button> element instead',
-              codeSnippet: getCodeSnippet(sourceCode, line),
-            });
-          }
-
-          if (!hasTabIndex) {
-            smells.push({
-              type: 'a11y-interactive-role',
-              severity: 'warning',
-              message: `Clickable <${elementName}> not focusable in "${component.name}"`,
-              file: filePath,
-              line,
-              column: loc?.start.column || 0,
-              suggestion: 'Add tabIndex={0} to make the element focusable',
-              codeSnippet: getCodeSnippet(sourceCode, line),
-            });
-          }
-
-          if (!hasKeyboardHandler) {
-            smells.push({
-              type: 'a11y-keyboard',
-              severity: 'info',
-              message: `Clickable <${elementName}> without keyboard handler in "${component.name}"`,
-              file: filePath,
-              line,
-              column: loc?.start.column || 0,
-              suggestion: 'Add onKeyDown to handle Enter/Space for keyboard users',
-              codeSnippet: getCodeSnippet(sourceCode, line),
-            });
-          }
-        }
-      }
-
-      // Check for anchor tags without href (should be buttons)
-      if (elementName === 'a') {
-        if (!hasAttr('href')) {
-          smells.push({
-            type: 'a11y-semantic',
-            severity: 'warning',
-            message: `<a> without href should be a <button> in "${component.name}"`,
-            file: filePath,
-            line,
-            column: loc?.start.column || 0,
-            suggestion: 'Use <button> for actions and <a href="..."> for navigation',
-            codeSnippet: getCodeSnippet(sourceCode, line),
-          });
-        }
-      }
-
-      // Check for proper button usage
-      if (elementName === 'button') {
-        if (!hasAttr('type')) {
-          smells.push({
-            type: 'a11y-semantic',
-            severity: 'info',
-            message: `<button> should have explicit type attribute`,
-            file: filePath,
-            line,
-            column: loc?.start.column || 0,
-            suggestion: 'Add type="button" or type="submit" to clarify button behavior',
-            codeSnippet: getCodeSnippet(sourceCode, line),
-          });
-        }
-      }
-
-      // Check for icons that might need labels
-      if (elementName === 'svg' || elementName === 'Icon' || elementName.endsWith('Icon')) {
-        const hasAriaLabel = hasAttr('aria-label') || hasAttr('aria-hidden') || hasAttr('title');
-        
-        if (!hasAriaLabel) {
-          smells.push({
-            type: 'a11y-missing-label',
-            severity: 'info',
-            message: `Icon/SVG may need aria-label or aria-hidden in "${component.name}"`,
-            file: filePath,
-            line,
-            column: loc?.start.column || 0,
-            suggestion: 'Add aria-label for meaningful icons, or aria-hidden="true" for decorative ones',
-            codeSnippet: getCodeSnippet(sourceCode, line),
-          });
-        }
-      }
-    },
-  });
-
-  return smells;
-}