react-code-smell-detector 1.4.2 → 1.5.1

package/dist/__tests__/fixer.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { isFixable, describeFixAction, getFixableTypes, fixFile } from '../fixer.js';
+// Use vi.hoisted to ensure mocks are available when vi.mock is hoisted
+const { mockReadFile, mockWriteFile } = vi.hoisted(() => ({
+    mockReadFile: vi.fn(),
+    mockWriteFile: vi.fn(),
+}));
+// Mock fs/promises default export
+vi.mock('fs/promises', () => ({
+    default: {
+        readFile: mockReadFile,
+        writeFile: mockWriteFile,
+    },
+    readFile: mockReadFile,
+    writeFile: mockWriteFile,
+}));
+describe('Fixer', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockReadFile.mockReset();
+        mockWriteFile.mockReset();
+    });
+    const createSmell = (type, line = 1) => ({
+        type,
+        severity: 'warning',
+        message: 'Test smell',
+        file: '/test.tsx',
+        line,
+        column: 0,
+        suggestion: 'Fix it',
+    });
+    describe('isFixable', () => {
+        it('should return true for debug-statement', () => {
+            expect(isFixable(createSmell('debug-statement'))).toBe(true);
+        });
+        it('should return true for js-var-usage', () => {
+            expect(isFixable(createSmell('js-var-usage'))).toBe(true);
+        });
+        it('should return true for js-loose-equality', () => {
+            expect(isFixable(createSmell('js-loose-equality'))).toBe(true);
+        });
+        it('should return true for a11y-missing-alt', () => {
+            expect(isFixable(createSmell('a11y-missing-alt'))).toBe(true);
+        });
+        it('should return false for non-fixable types', () => {
+            expect(isFixable(createSmell('useEffect-overuse'))).toBe(false);
+            expect(isFixable(createSmell('prop-drilling'))).toBe(false);
+            expect(isFixable(createSmell('large-component'))).toBe(false);
+        });
+    });
+    describe('describeFixAction', () => {
+        it('should describe debug-statement fix', () => {
+            const desc = describeFixAction('debug-statement');
+            expect(desc).toContain('console.log');
+        });
+        it('should describe js-var-usage fix', () => {
+            const desc = describeFixAction('js-var-usage');
+            expect(desc).toContain('var');
+            expect(desc).toContain('let');
+        });
+        it('should describe js-loose-equality fix', () => {
+            const desc = describeFixAction('js-loose-equality');
+            expect(desc).toContain('==');
+            expect(desc).toContain('===');
+        });
+        it('should describe a11y-missing-alt fix', () => {
+            const desc = describeFixAction('a11y-missing-alt');
+            expect(desc).toContain('alt');
+        });
+        it('should return not auto-fixable for unknown types', () => {
+            const desc = describeFixAction('useEffect-overuse');
+            expect(desc).toContain('Not auto-fixable');
+        });
+    });
+    describe('getFixableTypes', () => {
+        it('should return array of fixable types', () => {
+            const types = getFixableTypes();
+            expect(Array.isArray(types)).toBe(true);
+            expect(types).toContain('debug-statement');
+            expect(types).toContain('js-var-usage');
+            expect(types).toContain('js-loose-equality');
+            expect(types).toContain('a11y-missing-alt');
+        });
+        it('should return a copy, not the original array', () => {
+            const types1 = getFixableTypes();
+            const types2 = getFixableTypes();
+            expect(types1).not.toBe(types2);
+            expect(types1).toEqual(types2);
+        });
+    });
+    describe('fixFile', () => {
+        it('should return empty result when no fixable smells', async () => {
+            const smells = [createSmell('large-component')];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.file).toBe('/test.tsx');
+            expect(result.fixedSmells).toHaveLength(0);
+            expect(result.skippedSmells).toHaveLength(1);
+        });
+        it('should fix console.log statements by removing the line', async () => {
+            mockReadFile.mockResolvedValue(`const x = 1;
+console.log('debug');
+const y = 2;`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('debug-statement', 2)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            expect(mockWriteFile).toHaveBeenCalled();
+        });
+        it('should fix var to let', async () => {
+            mockReadFile.mockResolvedValue(`var x = 1;
+var y = 2;`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('js-var-usage', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            const writeCall = mockWriteFile.mock.calls[0];
+            expect(writeCall[1]).toContain('let x = 1');
+        });
+        it('should fix loose equality to strict equality', async () => {
+            mockReadFile.mockResolvedValue(`if (a == b) {
+  return true;
+}`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('js-loose-equality', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            const writeCall = mockWriteFile.mock.calls[0];
+            expect(writeCall[1]).toContain('===');
+        });
+        it('should fix missing alt attribute', async () => {
+            mockReadFile.mockResolvedValue(`<img src="test.jpg" />`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('a11y-missing-alt', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            const writeCall = mockWriteFile.mock.calls[0];
+            expect(writeCall[1]).toContain('alt=""');
+        });
+        it('should skip lines out of range', async () => {
+            mockReadFile.mockResolvedValue(`const x = 1;`);
+            const smells = [createSmell('debug-statement', 100)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(0);
+        });
+        it('should fix multiple smells in correct order (bottom-up)', async () => {
+            mockReadFile.mockResolvedValue(`var x = 1;
+console.log('test');
+var y = 2;`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [
+                createSmell('js-var-usage', 1),
+                createSmell('debug-statement', 2),
+                createSmell('js-var-usage', 3),
+            ];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(3);
+        });
+        it('should handle debugger statement', async () => {
+            mockReadFile.mockResolvedValue(`const x = 1;
+debugger;
+const y = 2;`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('debug-statement', 2)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+        });
+        it('should comment out console in expressions', async () => {
+            mockReadFile.mockResolvedValue(`const result = condition && console.log('test');`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('debug-statement', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            const writeCall = mockWriteFile.mock.calls[0];
+            expect(writeCall[1]).toContain('/*');
+        });
+        it('should not write file if no fixes applied', async () => {
+            mockReadFile.mockResolvedValue(`const x = 1;`);
+            const smells = [createSmell('debug-statement', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(0);
+            expect(mockWriteFile).not.toHaveBeenCalled();
+        });
+        it('should handle != to !== conversion', async () => {
+            mockReadFile.mockResolvedValue(`if (a != b) { return; }`);
+            mockWriteFile.mockResolvedValue(undefined);
+            const smells = [createSmell('js-loose-equality', 1)];
+            const result = await fixFile('/test.tsx', smells);
+            expect(result.fixedSmells).toHaveLength(1);
+            const writeCall = mockWriteFile.mock.calls[0];
+            expect(writeCall[1]).toContain('!==');
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/git.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { getGitInfo } from '../git.js';
+import os from 'os';
+describe('Git Utils', () => {
+    describe('getGitInfo', () => {
+        // Use the actual project directory for testing
+        const projectDir = process.cwd();
+        it('should return GitInfo object with isGitRepo property', () => {
+            const info = getGitInfo(projectDir);
+            expect(info).toHaveProperty('isGitRepo');
+            expect(typeof info.isGitRepo).toBe('boolean');
+        });
+        it('should return isGitRepo false for non-git directory', () => {
+            const tempDir = os.tmpdir();
+            const info = getGitInfo(tempDir);
+            expect(info.isGitRepo).toBe(false);
+        });
+        it('should include changedFiles array', () => {
+            const info = getGitInfo(projectDir);
+            expect(Array.isArray(info.changedFiles)).toBe(true);
+        });
+        it('should include stagedFiles array', () => {
+            const info = getGitInfo(projectDir);
+            expect(Array.isArray(info.stagedFiles)).toBe(true);
+        });
+        it('should include untrackedFiles array', () => {
+            const info = getGitInfo(projectDir);
+            expect(Array.isArray(info.untrackedFiles)).toBe(true);
+        });
+        it('should return proper GitInfo structure', () => {
+            const info = getGitInfo(projectDir);
+            expect(info).toHaveProperty('isGitRepo');
+            expect(info).toHaveProperty('changedFiles');
+            expect(info).toHaveProperty('stagedFiles');
+            expect(info).toHaveProperty('untrackedFiles');
+        });
+    });
+});

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

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

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

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

package/dist/__tests__/graphGenerator.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect } from 'vitest';
+import { buildDependencyGraph, generateDependencyGraph, generateDependencyGraphHTML } from '../graphGenerator.js';
+describe('Graph Generator', () => {
+    describe('buildDependencyGraph', () => {
+        it('should create empty graph for empty files', () => {
+            const graph = buildDependencyGraph([], '/root');
+            expect(graph.nodes.size).toBe(0);
+            expect(graph.edges.length).toBe(0);
+            expect(graph.circularDependencies.length).toBe(0);
+        });
+        it('should create nodes for files', () => {
+            const files = [
+                { file: '/root/src/App.tsx', imports: [] },
+                { file: '/root/src/Button.tsx', imports: [] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            expect(graph.nodes.size).toBe(2);
+        });
+        it('should create edges for imports', () => {
+            const files = [
+                { file: '/root/src/App.tsx', imports: ['/root/src/Button.tsx'] },
+                { file: '/root/src/Button.tsx', imports: [] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            expect(graph.edges.length).toBe(1);
+            expect(graph.edges[0].from).toContain('App');
+        });
+        it('should detect circular dependencies', () => {
+            const files = [
+                { file: '/root/src/A.tsx', imports: ['/root/src/B.tsx'] },
+                { file: '/root/src/B.tsx', imports: ['/root/src/A.tsx'] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            // Check that circular dependencies are detected
+            expect(graph.circularDependencies.length).toBeGreaterThanOrEqual(0);
+        });
+        it('should track importedBy for each node', () => {
+            const files = [
+                { file: '/root/src/App.tsx', imports: ['/root/src/Button.tsx'] },
+                { file: '/root/src/Button.tsx', imports: [] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            const buttonNode = Array.from(graph.nodes.values()).find(n => n.file.includes('Button'));
+            expect(buttonNode?.importedBy.length).toBeGreaterThanOrEqual(0);
+        });
+        it('should handle relative path normalization', () => {
+            const files = [
+                { file: '/root/src/deep/nested/Component.tsx', imports: ['/root/src/utils/helper.ts'] },
+                { file: '/root/src/utils/helper.ts', imports: [] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            expect(graph.nodes.size).toBe(2);
+        });
+        it('should mark circular nodes', () => {
+            const files = [
+                { file: '/root/A.tsx', imports: ['/root/B.tsx'] },
+                { file: '/root/B.tsx', imports: ['/root/C.tsx'] },
+                { file: '/root/C.tsx', imports: ['/root/A.tsx'] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            // Check if nodes are marked as circular
+            const circularNodes = Array.from(graph.nodes.values()).filter(n => n.isCircular);
+            expect(circularNodes.length).toBeGreaterThanOrEqual(0);
+        });
+        it('should mark circular edges', () => {
+            const files = [
+                { file: '/root/X.tsx', imports: ['/root/Y.tsx'] },
+                { file: '/root/Y.tsx', imports: ['/root/X.tsx'] },
+            ];
+            const graph = buildDependencyGraph(files, '/root');
+            const circularEdges = graph.edges.filter(e => e.circular);
+            expect(circularEdges.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('generateDependencyGraph', () => {
+        it('should generate SVG string', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('<svg');
+            expect(svg).toContain('</svg>');
+        });
+        it('should include arrow markers in SVG', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('marker');
+            expect(svg).toContain('arrowhead');
+        });
+        it('should include legend in SVG', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('Legend');
+        });
+        it('should use custom dimensions', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph, 800, 600);
+            expect(svg).toContain('width="800"');
+            expect(svg).toContain('height="600"');
+        });
+        it('should draw nodes', () => {
+            const nodes = new Map();
+            nodes.set('test', {
+                id: 'test',
+                file: '/test/Component.tsx',
+                type: 'file',
+                imports: [],
+                importedBy: [],
+            });
+            const graph = {
+                nodes,
+                edges: [],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('<circle');
+        });
+        it('should draw edges', () => {
+            const nodes = new Map();
+            nodes.set('a', { id: 'a', file: '/A.tsx', type: 'file', imports: ['b'], importedBy: [] });
+            nodes.set('b', { id: 'b', file: '/B.tsx', type: 'file', imports: [], importedBy: ['a'] });
+            const graph = {
+                nodes,
+                edges: [{ from: 'a', to: 'b', circular: false }],
+                circularDependencies: [],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('<line');
+        });
+        it('should style circular dependencies differently', () => {
+            const nodes = new Map();
+            nodes.set('a', { id: 'a', file: '/A.tsx', type: 'file', imports: ['b'], importedBy: ['b'], isCircular: true });
+            nodes.set('b', { id: 'b', file: '/B.tsx', type: 'file', imports: ['a'], importedBy: ['a'], isCircular: true });
+            const graph = {
+                nodes,
+                edges: [
+                    { from: 'a', to: 'b', circular: true },
+                    { from: 'b', to: 'a', circular: true },
+                ],
+                circularDependencies: [['a', 'b']],
+            };
+            const svg = generateDependencyGraph(graph);
+            expect(svg).toContain('#d32f2f'); // Red color for circular
+        });
+    });
+    describe('generateDependencyGraphHTML', () => {
+        it('should generate HTML document', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const html = generateDependencyGraphHTML(graph, 'Test Project');
+            expect(html).toContain('<!DOCTYPE html>');
+            expect(html).toContain('<html');
+        });
+        it('should include project name', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const html = generateDependencyGraphHTML(graph, 'My Project');
+            expect(html).toContain('My Project');
+        });
+        it('should include SVG graph', () => {
+            const graph = {
+                nodes: new Map(),
+                edges: [],
+                circularDependencies: [],
+            };
+            const html = generateDependencyGraphHTML(graph, 'Test');
+            expect(html).toContain('<svg');
+        });
+    });
+});

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

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

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

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