react-code-smell-detector 1.4.2 → 1.5.1

package/dist/__tests__/analyzer.test.js

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock dependencies for analyzer
+vi.mock('fast-glob', () => ({
+    default: vi.fn().mockResolvedValue([]),
+}));
+vi.mock('ora', () => ({
+    default: () => ({
+        start: vi.fn().mockReturnThis(),
+        succeed: vi.fn().mockReturnThis(),
+        fail: vi.fn().mockReturnThis(),
+        stop: vi.fn().mockReturnThis(),
+        text: '',
+    }),
+}));
+describe('Analyzer', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('analyzeProject', () => {
+        it('should accept project path', () => {
+            const projectPath = '/path/to/project';
+            expect(typeof projectPath).toBe('string');
+        });
+        it('should accept options object', () => {
+            const options = {
+                verbose: true,
+                fix: false,
+                format: 'json',
+            };
+            expect(options.verbose).toBe(true);
+            expect(options.fix).toBe(false);
+            expect(options.format).toBe('json');
+        });
+        it('should handle default options', () => {
+            const defaultOptions = {
+                verbose: false,
+                fix: false,
+                format: 'console',
+                include: ['**/*.tsx', '**/*.jsx', '**/*.ts', '**/*.js'],
+                exclude: ['node_modules/**', 'dist/**', 'build/**'],
+            };
+            expect(defaultOptions.include).toContain('**/*.tsx');
+            expect(defaultOptions.exclude).toContain('node_modules/**');
+        });
+        it('should support various output formats', () => {
+            const formats = ['json', 'console', 'markdown', 'html', 'sarif'];
+            formats.forEach(format => {
+                expect(['json', 'console', 'markdown', 'html', 'sarif']).toContain(format);
+            });
+        });
+    });
+    describe('File pattern matching', () => {
+        it('should match React file extensions', () => {
+            const patterns = ['**/*.tsx', '**/*.jsx', '**/*.ts', '**/*.js'];
+            const testFiles = [
+                'src/App.tsx',
+                'src/utils/helper.ts',
+                'components/Button.jsx',
+                'lib/index.js',
+            ];
+            testFiles.forEach(file => {
+                const matches = patterns.some(pattern => {
+                    const ext = pattern.replace('**/*', '');
+                    return file.endsWith(ext);
+                });
+                expect(matches).toBe(true);
+            });
+        });
+        it('should exclude node_modules and build dirs', () => {
+            const excludePatterns = ['node_modules/**', 'dist/**', 'build/**'];
+            const shouldExclude = (file) => {
+                return excludePatterns.some(pattern => {
+                    const dir = pattern.replace('/**', '');
+                    return file.startsWith(dir + '/') || file.startsWith(dir);
+                });
+            };
+            expect(shouldExclude('node_modules/react/index.js')).toBe(true);
+            expect(shouldExclude('dist/bundle.js')).toBe(true);
+            expect(shouldExclude('build/output.js')).toBe(true);
+            expect(shouldExclude('src/App.tsx')).toBe(false);
+        });
+    });
+    describe('Options validation', () => {
+        it('should validate format option', () => {
+            const validFormats = ['json', 'console', 'markdown', 'html', 'sarif'];
+            const isValidFormat = (format) => validFormats.includes(format);
+            expect(isValidFormat('json')).toBe(true);
+            expect(isValidFormat('invalid')).toBe(false);
+        });
+        it('should validate threshold is positive number', () => {
+            const isValidThreshold = (threshold) => {
+                return typeof threshold === 'number' && threshold >= 0;
+            };
+            expect(isValidThreshold(10)).toBe(true);
+            expect(isValidThreshold(0)).toBe(true);
+            expect(isValidThreshold(-1)).toBe(false);
+            expect(isValidThreshold('10')).toBe(false);
+        });
+        it('should validate custom rules path', () => {
+            const isValidPath = (path) => {
+                return typeof path === 'string' && path.length > 0;
+            };
+            expect(isValidPath('./rules.json')).toBe(true);
+            expect(isValidPath('')).toBe(false);
+            expect(isValidPath(null)).toBe(false);
+        });
+    });
+    describe('Analysis results structure', () => {
+        it('should have correct result shape', () => {
+            const mockResult = {
+                smells: [],
+                filesAnalyzed: 10,
+                totalSmells: 0,
+                byType: {},
+                bySeverity: { error: 0, warning: 0, info: 0 },
+            };
+            expect(mockResult).toHaveProperty('smells');
+            expect(mockResult).toHaveProperty('filesAnalyzed');
+            expect(mockResult).toHaveProperty('totalSmells');
+            expect(mockResult).toHaveProperty('byType');
+            expect(mockResult).toHaveProperty('bySeverity');
+        });
+        it('should aggregate smells by type', () => {
+            const smells = [
+                { type: 'debug-statement' },
+                { type: 'debug-statement' },
+                { type: 'js-var-usage' },
+            ];
+            const byType = smells.reduce((acc, s) => {
+                acc[s.type] = (acc[s.type] || 0) + 1;
+                return acc;
+            }, {});
+            expect(byType['debug-statement']).toBe(2);
+            expect(byType['js-var-usage']).toBe(1);
+        });
+        it('should aggregate smells by severity', () => {
+            const smells = [
+                { severity: 'error' },
+                { severity: 'warning' },
+                { severity: 'warning' },
+                { severity: 'info' },
+            ];
+            const bySeverity = smells.reduce((acc, s) => {
+                acc[s.severity] = (acc[s.severity] || 0) + 1;
+                return acc;
+            }, { error: 0, warning: 0, info: 0 });
+            expect(bySeverity.error).toBe(1);
+            expect(bySeverity.warning).toBe(2);
+            expect(bySeverity.info).toBe(1);
+        });
+    });
+    describe('Performance', () => {
+        it('should batch file processing efficiently', () => {
+            const files = Array(100).fill(null).map((_, i) => `file${i}.tsx`);
+            const batchSize = 10;
+            const batches = [];
+            for (let i = 0; i < files.length; i += batchSize) {
+                batches.push(files.slice(i, i + batchSize));
+            }
+            expect(batches).toHaveLength(10);
+            expect(batches[0]).toHaveLength(10);
+        });
+        it('should handle concurrent file analysis', async () => {
+            const analyzeFile = async (file) => {
+                return { file, smells: [] };
+            };
+            const files = ['a.tsx', 'b.tsx', 'c.tsx'];
+            const results = await Promise.all(files.map(analyzeFile));
+            expect(results).toHaveLength(3);
+            expect(results[0].file).toBe('a.tsx');
+        });
+    });
+});

package/dist/__tests__/baseline.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=baseline.test.d.ts.map

package/dist/__tests__/baseline.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/baseline.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/baseline.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { initializeBaseline, recordBaseline, getTrendAnalysis } from '../baseline.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+describe('Baseline', () => {
+    let tempDir;
+    beforeEach(() => {
+        // Create a temporary directory for tests
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'baseline-test-'));
+    });
+    afterEach(() => {
+        // Clean up temporary directory
+        try {
+            fs.rmSync(tempDir, { recursive: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    const createSmell = (type) => ({
+        type: type,
+        severity: 'warning',
+        message: 'Test smell',
+        file: '/test.tsx',
+        line: 1,
+        column: 0,
+        suggestion: 'Fix it',
+    });
+    describe('initializeBaseline', () => {
+        it('should create baseline file if it does not exist', () => {
+            initializeBaseline(tempDir);
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            expect(fs.existsSync(baselinePath)).toBe(true);
+        });
+        it('should not overwrite existing baseline file', () => {
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            // Create initial baseline
+            initializeBaseline(tempDir);
+            // Add a record
+            recordBaseline(tempDir, [createSmell('debug-statement')]);
+            // Reinitialize
+            initializeBaseline(tempDir);
+            // Check that record still exists
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.records.length).toBeGreaterThan(0);
+        });
+        it('should create valid JSON structure', () => {
+            initializeBaseline(tempDir);
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.version).toBe('1.0');
+            expect(Array.isArray(data.records)).toBe(true);
+        });
+    });
+    describe('recordBaseline', () => {
+        it('should add a record to baseline', () => {
+            initializeBaseline(tempDir);
+            const smells = [createSmell('debug-statement'), createSmell('js-var-usage')];
+            const record = recordBaseline(tempDir, smells);
+            expect(record.totalSmells).toBe(2);
+            expect(record.byType['debug-statement']).toBe(1);
+            expect(record.byType['js-var-usage']).toBe(1);
+        });
+        it('should include timestamp', () => {
+            initializeBaseline(tempDir);
+            const record = recordBaseline(tempDir, [createSmell('debug-statement')]);
+            expect(record.timestamp).toBeDefined();
+            expect(new Date(record.timestamp).getTime()).toBeLessThanOrEqual(Date.now());
+        });
+        it('should include commit hash when provided', () => {
+            initializeBaseline(tempDir);
+            const record = recordBaseline(tempDir, [createSmell('debug-statement')], 'abc123');
+            expect(record.commit).toBe('abc123');
+        });
+        it('should keep only last 50 records', () => {
+            initializeBaseline(tempDir);
+            // Add 55 records
+            for (let i = 0; i < 55; i++) {
+                recordBaseline(tempDir, [createSmell('debug-statement')]);
+            }
+            const baselinePath = path.join(tempDir, '.smellrc-baseline.json');
+            const data = JSON.parse(fs.readFileSync(baselinePath, 'utf-8'));
+            expect(data.records.length).toBe(50);
+        });
+        it('should limit stored smells to 100', () => {
+            initializeBaseline(tempDir);
+            // Create 150 smells
+            const manySmells = Array(150).fill(null).map(() => createSmell('debug-statement'));
+            const record = recordBaseline(tempDir, manySmells);
+            expect(record.totalSmells).toBe(150);
+            expect(record.smells.length).toBe(100);
+        });
+    });
+    describe('getTrendAnalysis', () => {
+        it('should return stable when no baseline exists', () => {
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+            expect(trend.improved).toBe(0);
+            expect(trend.worsened).toBe(0);
+        });
+        it('should return stable with only one record', () => {
+            initializeBaseline(tempDir);
+            recordBaseline(tempDir, [createSmell('debug-statement')]);
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+        });
+        it('should detect improving trend', () => {
+            initializeBaseline(tempDir);
+            // First record: 5 smells
+            recordBaseline(tempDir, Array(5).fill(null).map(() => createSmell('debug-statement')));
+            // Second record: 3 smells (improved)
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('improving');
+            expect(trend.improved).toBe(2);
+        });
+        it('should detect worsening trend', () => {
+            initializeBaseline(tempDir);
+            // First record: 3 smells
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            // Second record: 5 smells (worsened)
+            recordBaseline(tempDir, Array(5).fill(null).map(() => createSmell('debug-statement')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('worsening');
+            expect(trend.worsened).toBe(2);
+        });
+        it('should return stable when same count', () => {
+            initializeBaseline(tempDir);
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('debug-statement')));
+            recordBaseline(tempDir, Array(3).fill(null).map(() => createSmell('js-var-usage')));
+            const trend = getTrendAnalysis(tempDir);
+            expect(trend.trend).toBe('stable');
+        });
+    });
+});

package/dist/__tests__/bundleAnalyzer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bundleAnalyzer.test.d.ts.map

package/dist/__tests__/bundleAnalyzer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleAnalyzer.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/bundleAnalyzer.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/bundleAnalyzer.test.js

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import { analyzeBundleImpact } from '../bundleAnalyzer.js';
+describe('Bundle Analyzer', () => {
+    describe('analyzeBundleImpact', () => {
+        it('should return empty results for empty components', () => {
+            const result = analyzeBundleImpact([], [], '');
+            expect(result.components).toEqual([]);
+            expect(result.totalEstimatedSize).toBe(0);
+            expect(result.averageComponentSize).toBe(0);
+            expect(result.largestComponents).toEqual([]);
+        });
+        it('should analyze component with basic structure', () => {
+            const mockComponent = {
+                name: 'TestComponent',
+                file: '/test/Component.tsx',
+                code: 'function TestComponent() { return <div>Test</div>; }',
+                path: {
+                    traverse: (visitor) => {
+                        // Simulate no exports or imports
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([mockComponent], [], '');
+            expect(result.components.length).toBe(1);
+            expect(result.components[0].name).toBe('TestComponent');
+            expect(result.totalEstimatedSize).toBeGreaterThan(0);
+        });
+        it('should detect exports', () => {
+            let exportCount = 0;
+            const mockComponent = {
+                name: 'ExportComponent',
+                file: '/test/Export.tsx',
+                code: 'export function ExportComponent() { return <div>Export</div>; }',
+                path: {
+                    traverse: (visitor) => {
+                        if (visitor.ExportNamedDeclaration) {
+                            visitor.ExportNamedDeclaration();
+                            exportCount++;
+                        }
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([mockComponent], [], '');
+            expect(result.components[0].exports).toBeGreaterThanOrEqual(0);
+        });
+        it('should detect dependencies', () => {
+            const mockComponent = {
+                name: 'ImportComponent',
+                file: '/test/Import.tsx',
+                code: 'import React from "react"; function ImportComponent() { return <div>Import</div>; }',
+                path: {
+                    traverse: (visitor) => {
+                        if (visitor.ImportDeclaration) {
+                            visitor.ImportDeclaration();
+                        }
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([mockComponent], [], '');
+            expect(result.components[0].dependencies).toBeGreaterThanOrEqual(0);
+        });
+        it('should calculate complexity', () => {
+            const mockComponent = {
+                name: 'ComplexComponent',
+                file: '/test/Complex.tsx',
+                code: `
+          function ComplexComponent() {
+            if (true) { return <div>A</div>; }
+            const fn = () => {};
+            return <div>B</div>;
+          }
+        `,
+                path: {
+                    traverse: (visitor) => {
+                        if (visitor.IfStatement)
+                            visitor.IfStatement();
+                        if (visitor.ArrowFunctionExpression)
+                            visitor.ArrowFunctionExpression();
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([mockComponent], [], '');
+            expect(result.components[0].complexity).toBeGreaterThan(0);
+        });
+        it('should sort components by size', () => {
+            const smallComponent = {
+                name: 'Small',
+                file: '/test/Small.tsx',
+                code: 'x',
+                path: { traverse: () => { } },
+            };
+            const largeComponent = {
+                name: 'Large',
+                file: '/test/Large.tsx',
+                code: Array(100).fill('const x = 1;').join('\n'),
+                path: { traverse: () => { } },
+            };
+            const result = analyzeBundleImpact([smallComponent, largeComponent], [], '');
+            expect(result.largestComponents[0].name).toBe('Large');
+        });
+        it('should generate recommendations', () => {
+            const hugeComponent = {
+                name: 'Huge',
+                file: '/test/Huge.tsx',
+                code: Array(600).fill('const x = 1;').join('\n'),
+                path: {
+                    traverse: (visitor) => {
+                        // Simulate lots of imports
+                        for (let i = 0; i < 20; i++) {
+                            if (visitor.ImportDeclaration)
+                                visitor.ImportDeclaration();
+                        }
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([hugeComponent], [], '');
+            expect(result.recommendations).toBeDefined();
+            expect(Array.isArray(result.recommendations)).toBe(true);
+        });
+        it('should determine impact levels', () => {
+            const criticalComponent = {
+                name: 'Critical',
+                file: '/test/Critical.tsx',
+                code: Array(600).fill('const x = 1;').join('\n'),
+                path: {
+                    traverse: (visitor) => {
+                        // High complexity
+                        for (let i = 0; i < 30; i++) {
+                            if (visitor.IfStatement)
+                                visitor.IfStatement();
+                            if (visitor.FunctionDeclaration)
+                                visitor.FunctionDeclaration();
+                            if (visitor.ArrowFunctionExpression)
+                                visitor.ArrowFunctionExpression();
+                        }
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([criticalComponent], [], '');
+            const impact = result.components[0].impact;
+            expect(['low', 'medium', 'high', 'critical']).toContain(impact);
+        });
+        it('should handle component without code property', () => {
+            const componentNoCode = {
+                name: 'NoCode',
+                file: '/test/NoCode.tsx',
+                path: { traverse: () => { } },
+            };
+            const result = analyzeBundleImpact([componentNoCode], [], '');
+            expect(result.components.length).toBe(1);
+            expect(result.components[0].estimatedSize).toBeGreaterThan(0); // Base overhead
+        });
+        it('should handle dynamic imports', () => {
+            const dynamicComponent = {
+                name: 'Dynamic',
+                file: '/test/Dynamic.tsx',
+                code: 'const Lazy = React.lazy(() => import("./Lazy"));',
+                path: {
+                    traverse: (visitor) => {
+                        if (visitor.CallExpression) {
+                            visitor.CallExpression({
+                                node: { callee: { type: 'Import' } },
+                            });
+                        }
+                    },
+                },
+            };
+            const result = analyzeBundleImpact([dynamicComponent], [], '');
+            expect(result.components[0].dependencies).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('BundleAnalysisResult structure', () => {
+        it('should have correct result structure', () => {
+            const result = analyzeBundleImpact([], [], '');
+            expect(result).toHaveProperty('components');
+            expect(result).toHaveProperty('totalEstimatedSize');
+            expect(result).toHaveProperty('averageComponentSize');
+            expect(result).toHaveProperty('largestComponents');
+            expect(result).toHaveProperty('recommendations');
+        });
+    });
+});

package/dist/__tests__/customRules.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=customRules.test.d.ts.map

package/dist/__tests__/customRules.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customRules.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/customRules.test.ts"],"names":[],"mappings":""}