esupgrade 2025.0.0 → 2025.0.1

package/tests/cli.test.js

@@ -0,0 +1,358 @@
+import { describe, test, beforeEach, afterEach } from "node:test"
+import assert from "node:assert"
+import { execSync, spawnSync } from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const CLI_PATH = path.join(process.cwd(), "bin", "esupgrade.js")
+
+describe("CLI", () => {
+  let tempDir
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "esupgrade-test-"))
+  })
+
+  afterEach(() => {
+    if (tempDir && fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+
+  test("should display help when no files specified", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /Error: No files specified/)
+    // Commander shows help and exits with 0
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should transform a single file with --write", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    const transformedCode = fs.readFileSync(testFile, "utf8")
+    assert.match(transformedCode, /const x = 1/)
+    assert.match(result.stdout, /Summary: 1 file\(s\) upgraded/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should transform files with widely-available baseline by default", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    const transformedCode = fs.readFileSync(testFile, "utf8")
+    assert.match(transformedCode, /const x = 1/)
+    assert.doesNotMatch(transformedCode, /Promise\.try/) // Promise.try not in widely-available
+    assert.match(result.stdout, /widely-available/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should transform files with newly-available baseline", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;\nconst p = new Promise((resolve) => resolve(getData()));`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, testFile, "--baseline", "newly-available", "--write"],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    const transformedCode = fs.readFileSync(testFile, "utf8")
+    assert.match(transformedCode, /const x = 1/)
+    assert.match(transformedCode, /Promise\.try/) // Promise.try in newly-available
+    assert.match(result.stdout, /newly-available/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should check files without writing with --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    const fileContent = fs.readFileSync(testFile, "utf8")
+    assert.strictEqual(fileContent, originalCode) // File unchanged
+    assert.match(result.stdout, /✗/)
+    assert.match(result.stdout, /1 file\(s\) need upgrading/)
+    assert.strictEqual(result.status, 1) // Exit with code 1 when changes needed
+  })
+
+  test("should exit with 0 when --check and no changes needed", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `const x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    const fileContent = fs.readFileSync(testFile, "utf8")
+    assert.strictEqual(fileContent, originalCode) // File unchanged
+    assert.match(result.stdout, /All files are already modern/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should support both --check and --write together", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, testFile, "--check", "--write"],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    const transformedCode = fs.readFileSync(testFile, "utf8")
+    assert.match(transformedCode, /const x = 1/)
+    assert.match(result.stdout, /✗/)
+    assert.match(result.stdout, /Changes written to file/)
+    assert.match(result.stdout, /1 file\(s\) upgraded/)
+    assert.strictEqual(result.status, 1) // Still exit 1 with --check
+  })
+
+  test("should process directory recursively", () => {
+    const subDir = path.join(tempDir, "src")
+    fs.mkdirSync(subDir)
+
+    const file1 = path.join(tempDir, "test1.js")
+    const file2 = path.join(subDir, "test2.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `var y = 2;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, tempDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    const transformed1 = fs.readFileSync(file1, "utf8")
+    const transformed2 = fs.readFileSync(file2, "utf8")
+    assert.match(transformed1, /const x = 1/)
+    assert.match(transformed2, /const y = 2/)
+    assert.match(result.stdout, /Processing 2 file/)
+    assert.match(result.stdout, /2 file\(s\) upgraded/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should skip node_modules and .git directories", () => {
+    const nodeModules = path.join(tempDir, "node_modules")
+    const gitDir = path.join(tempDir, ".git")
+    fs.mkdirSync(nodeModules)
+    fs.mkdirSync(gitDir)
+
+    const file1 = path.join(tempDir, "test.js")
+    const file2 = path.join(nodeModules, "test.js")
+    const file3 = path.join(gitDir, "test.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `var y = 2;`)
+    fs.writeFileSync(file3, `var z = 3;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, tempDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /Processing 1 file/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should process multiple file extensions", () => {
+    const jsFile = path.join(tempDir, "test.js")
+    const mjsFile = path.join(tempDir, "test.mjs")
+    const cjsFile = path.join(tempDir, "test.cjs")
+    const jsxFile = path.join(tempDir, "test.jsx")
+
+    fs.writeFileSync(jsFile, `var a = 1;`)
+    fs.writeFileSync(mjsFile, `var b = 2;`)
+    fs.writeFileSync(cjsFile, `var c = 3;`)
+    fs.writeFileSync(jsxFile, `var d = 4;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, tempDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /Processing 4 file/)
+    assert.match(result.stdout, /4 file\(s\) upgraded/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should handle TypeScript file extensions", () => {
+    const tsFile = path.join(tempDir, "test.ts")
+    const tsxFile = path.join(tempDir, "test.tsx")
+
+    fs.writeFileSync(tsFile, `var a = 1;`)
+    fs.writeFileSync(tsxFile, `var b = 2;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, tempDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /Processing 2 file/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should error on invalid baseline", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, `var x = 1;`)
+
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, testFile, "--baseline", "invalid"],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    assert.match(result.stderr, /error/)
+    assert.strictEqual(result.status, 1)
+  })
+
+  test("should error on non-existent file", () => {
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, path.join(tempDir, "nonexistent.js")],
+      {
+        encoding: "utf8",
+      },
+    )
+
+    assert.match(result.stderr, /Error: Cannot access/)
+    assert.strictEqual(result.status, 1)
+  })
+
+  test("should show detailed changes with --check", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;\nvar y = 2;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /var to const/)
+    assert.match(result.stdout, /line/)
+    assert.strictEqual(result.status, 1)
+  })
+
+  test("should process multiple files specified as arguments", () => {
+    const file1 = path.join(tempDir, "test1.js")
+    const file2 = path.join(tempDir, "test2.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `var y = 2;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, file1, file2, "--write"], {
+      encoding: "utf8",
+    })
+
+    const transformed1 = fs.readFileSync(file1, "utf8")
+    const transformed2 = fs.readFileSync(file2, "utf8")
+    assert.match(transformed1, /const x = 1/)
+    assert.match(transformed2, /const y = 2/)
+    assert.match(result.stdout, /Processing 2 file/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should handle files with no changes needed", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `const x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    const fileContent = fs.readFileSync(testFile, "utf8")
+    assert.strictEqual(fileContent, originalCode)
+    assert.match(result.stdout, /All files are already modern/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should show no changes message for individual files", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `const x = 1;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /No changes:/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should handle empty directory", () => {
+    const emptyDir = path.join(tempDir, "empty")
+    fs.mkdirSync(emptyDir)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, emptyDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /No JavaScript files found/)
+    assert.strictEqual(result.status, 0)
+  })
+
+  test("should group changes by type in --check output", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const originalCode = `var x = 1;\nvar y = 2;\nvar z = 3;`
+    fs.writeFileSync(testFile, originalCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--check"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /var to const/)
+    assert.match(result.stdout, /lines:/)
+    assert.strictEqual(result.status, 1)
+  })
+
+  test("should handle syntax errors gracefully", () => {
+    const testFile = path.join(tempDir, "test.js")
+    const invalidCode = `var x = {{{;`
+    fs.writeFileSync(testFile, invalidCode)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, testFile, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stderr, /Error processing/)
+    assert.strictEqual(result.status, 0) // CLI continues despite errors
+  })
+
+  test("should handle mixed directory and file arguments", () => {
+    const subDir = path.join(tempDir, "src")
+    fs.mkdirSync(subDir)
+
+    const file1 = path.join(tempDir, "test1.js")
+    const file2 = path.join(subDir, "test2.js")
+    fs.writeFileSync(file1, `var x = 1;`)
+    fs.writeFileSync(file2, `var y = 2;`)
+
+    const result = spawnSync(process.execPath, [CLI_PATH, file1, subDir, "--write"], {
+      encoding: "utf8",
+    })
+
+    assert.match(result.stdout, /Processing 2 file/)
+    assert.strictEqual(result.status, 0)
+  })
+})

package/tests/index.test.js

@@ -0,0 +1,274 @@
+import { describe, test } from "node:test"
+import assert from "node:assert"
+import { transform } from "../src/index.js"
+
+describe("index", () => {
+  describe("transform function", () => {
+    test("should return TransformResult with correct structure", () => {
+      const input = `var x = 1;`
+      const result = transform(input)
+
+      assert.ok(result.hasOwnProperty("code"))
+      assert.ok(result.hasOwnProperty("modified"))
+      assert.ok(result.hasOwnProperty("changes"))
+      assert.strictEqual(typeof result.code, "string")
+      assert.strictEqual(typeof result.modified, "boolean")
+      assert.ok(Array.isArray(result.changes))
+    })
+
+    test("should handle empty string", () => {
+      const input = ``
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.strictEqual(result.changes.length, 0)
+      assert.strictEqual(result.code, "")
+    })
+
+    test("should handle whitespace-only string", () => {
+      const input = `   \n\n   `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.strictEqual(result.changes.length, 0)
+    })
+
+    test("should handle comments only", () => {
+      const input = `// This is a comment\n/* Another comment */`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.strictEqual(result.changes.length, 0)
+    })
+
+    test("should apply multiple transformations and track all changes", () => {
+      const input = `
+        var x = 1;
+        var y = 'Hello ' + name;
+        var obj = Object.assign({}, data);
+      `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.ok(result.changes.length > 0)
+
+      // Should have changes from varToConst (which does track line numbers)
+      const changeTypes = result.changes.map((c) => c.type)
+      assert.ok(changeTypes.includes("varToConst"))
+
+      // Verify the transformations happened even if not all are tracked
+      assert.match(result.code, /const/)
+      assert.match(result.code, /`Hello/)
+      assert.match(result.code, /\.\.\.data/)
+    })
+
+    test("should aggregate changes from multiple transformers", () => {
+      const input = `
+        var a = 1;
+        var b = 'Hello ' + world;
+        Array.from(items).forEach(item => console.log(item));
+      `
+      const result = transform(input, "widely-available")
+
+      assert.strictEqual(result.modified, true)
+
+      // Should track line numbers for all changes
+      assert.ok(result.changes.every((c) => c.hasOwnProperty("line")))
+      assert.ok(result.changes.every((c) => c.hasOwnProperty("type")))
+    })
+
+    test("should use widely-available transformers by default", () => {
+      const input = `var x = 1;`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes[0].type, "varToConst")
+    })
+
+    test("should include newly-available transformers when specified", () => {
+      const input = `
+        var x = 1;
+        const p = new Promise((resolve) => resolve(getData()));
+      `
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+
+      const changeTypes = result.changes.map((c) => c.type)
+      assert.ok(changeTypes.includes("varToConst"))
+      assert.ok(changeTypes.includes("promiseTry"))
+    })
+
+    test("should handle complex nested structures", () => {
+      const input = `
+        function test() {
+          var result = Object.assign({}, {
+            message: 'Hello ' + name
+          });
+          return result;
+        }
+      `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const result/)
+      assert.match(result.code, /\.\.\./)
+      assert.match(result.code, /`Hello/)
+    })
+
+    test("should handle JSX syntax", () => {
+      const input = `
+        var Component = () => {
+          var title = 'Hello ' + name;
+          return <div>{title}</div>;
+        };
+      `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const/)
+      assert.match(result.code, /<div>/)
+    })
+
+    test("should handle TypeScript syntax", () => {
+      const input = `
+        var x: number = 1;
+        const greeting: string = 'Hello ' + name;
+      `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const x: number/)
+      assert.match(result.code, /`Hello/)
+    })
+
+    test("should preserve code formatting structure", () => {
+      const input = `var x = 1;
+var y = 2;`
+      const result = transform(input)
+
+      // Should maintain separation between statements
+      assert.match(result.code, /const x = 1/)
+      assert.match(result.code, /const y = 2/)
+    })
+
+    test("should handle very large code", () => {
+      // Generate a large input with many var declarations
+      const lines = []
+      for (let i = 0; i < 100; i++) {
+        lines.push(`var x${i} = ${i};`)
+      }
+      const input = lines.join("\n")
+
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.strictEqual(result.changes.length, 100)
+      assert.match(result.code, /const x0 = 0/)
+      assert.match(result.code, /const x99 = 99/)
+    })
+
+    test("should handle code with special characters", () => {
+      const input = `var msg = 'Hello \\n' + 'World\\t!';`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const msg/)
+      // Template literals preserve the escape sequences
+      assert.match(result.code, /`Hello/)
+    })
+
+    test("should handle code with unicode characters", () => {
+      const input = `var msg = 'Hello ' + '世界' + '!';`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const msg/)
+    })
+
+    test("should handle all transformers returning no changes", () => {
+      const input = `const x = 1; const y = 2;`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, false)
+      assert.strictEqual(result.changes.length, 0)
+    })
+
+    test("should handle baseline parameter case sensitivity", () => {
+      const input = `var x = 1;`
+
+      // Should accept exact strings
+      const result1 = transform(input, "widely-available")
+      assert.strictEqual(result1.modified, true)
+
+      const result2 = transform(input, "newly-available")
+      assert.strictEqual(result2.modified, true)
+    })
+
+    test("should merge transformers correctly for newly-available", () => {
+      const input = `
+        var x = 1;
+        var obj = Object.assign({}, data);
+        const p = new Promise((resolve) => resolve(getData()));
+      `
+      const result = transform(input, "newly-available")
+
+      assert.strictEqual(result.modified, true)
+
+      // Should have changes from transformers that track line numbers
+      const changeTypes = result.changes.map((c) => c.type)
+      assert.ok(changeTypes.includes("varToConst")) // from widely-available
+      assert.ok(changeTypes.includes("promiseTry")) // from newly-available
+
+      // Verify all transformations happened
+      assert.match(result.code, /const/)
+      assert.match(result.code, /\.\.\.data/)
+      assert.match(result.code, /Promise\.try/)
+    })
+
+    test("should handle code without location info gracefully", () => {
+      // Even if some transformations don't have location info, should still work
+      const input = `var x = 1;`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      // Should handle missing loc info gracefully
+    })
+
+    test("should generate valid JavaScript output", () => {
+      const input = `
+        var x = 1;
+        var greeting = 'Hello ' + name;
+        Array.from(items).forEach(item => console.log(item));
+      `
+      const result = transform(input)
+
+      // Try to parse the output to ensure it's valid JS
+      assert.doesNotThrow(() => {
+        new Function(result.code)
+      })
+    })
+
+    test("should handle single-line code", () => {
+      const input = `var x = 1; var y = 2; var z = 3;`
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const x = 1/)
+      assert.match(result.code, /const y = 2/)
+      assert.match(result.code, /const z = 3/)
+    })
+
+    test("should handle code with existing template literals", () => {
+      const input = `
+        var msg = \`Hello \${name}\`;
+        var other = 'Test ' + value;
+      `
+      const result = transform(input)
+
+      assert.strictEqual(result.modified, true)
+      assert.match(result.code, /const msg/)
+      assert.match(result.code, /const other/)
+    })
+  })
+})