@nudojs/cli 0.2.0 → 0.2.1

package/src/__tests__/mock-arrow-function.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect } from "vitest";
+import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+import { analyzeFile } from "@nudojs/service";
+
+function inferWithMocks(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    // Apply mocks first
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Mock Arrow Functions", () => {
+  it("supports arrow function mock with direct call", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => x > 3
+// @nudo:case "num" (5)
+function test(x) {
+  return fn(x);
+}
+`);
+    // fn(5) should return true since 5 > 3
+    expect(results[0].result).toBe("true");
+  });
+
+  it("supports arrow function mock for filter", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => x > 3
+// @nudo:case "nums" ([1, 2, 3, 4, 5])
+function filter(arr) {
+  const result = [];
+  for (const item of arr) {
+    if (fn(item)) result.push(item);
+  }
+  return result;
+}
+`);
+    // Should filter to [4, 5]
+    expect(results[0].result).toBe("[4, 5]");
+  });
+
+  it("supports arrow function mock with multiple params", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (a, b) => a + b
+// @nudo:case "nums" ([1, 2, 3])
+function sum(arr) {
+  return arr.reduce(fn, 0);
+}
+`);
+    // reduce with (a, b) => a + b and [1, 2, 3] should give 6
+    expect(results[0].result).toBe("6");
+  });
+
+  it("supports arrow function mock with string operations", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => x.toUpperCase()
+// @nudo:case "str" ("hello")
+function transform(x) {
+  return fn(x);
+}
+`);
+    // fn("hello") should return "HELLO"
+    expect(results[0].result).toBe('"HELLO"');
+  });
+});
+
+describe("Mock Arrow Functions: builtin HOF propagation", () => {
+  it("mock arrow propagates through items.map(fn) with object results", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => ({ ok: true })
+// @nudo:case "items" ([1, 2, 3])
+function applyAll(items) {
+  return items.map(fn);
+}
+`);
+    // mock 函数值透传给 builtin HOF：与内联箭头 items.map(x => ({ ok: true })) 同机制
+    expect(results[0].result).toBe("[{ ok: true }, { ok: true }, { ok: true }]");
+  });
+
+  it("mock arrow keeps propagating when the receiver is a union of arrays", () => {
+    const results = inferWithMocks(`
+// @nudo:mock fn = (x) => ({ ok: true })
+// @nudo:case "go" ()
+function applyUnion() {
+  const items = Math.random() > 0.5 ? [1, 2] : [3, 4, 5];
+  return items.map(fn);
+}
+`);
+    // union 接收者按成员分布求值，不再保守降级 unknown
+    expect(results[0].result).toBe("[{ ok: true }, { ok: true }] | [{ ok: true }, { ok: true }, { ok: true }]");
+  });
+
+  it("mock arrow reduce(fn, 0) over a union receiver still accumulates", () => {
+    const results = inferWithMocks(`
+// @nudo:mock add = (a, b) => a + b
+// @nudo:case "go" ()
+function sumUnion() {
+  const xs = Math.random() > 0.5 ? [1, 2] : [3, 4, 5];
+  return xs.reduce(add, 0);
+}
+`);
+    expect(results[0].result).toBe("3 | 12");
+  });
+});
+
+describe("Mock Arrow Functions: callback arg through call sites", () => {
+  // 直接走 analyzer 主路径：mock 绑定必须先于全程序求值，顶层调用点
+  // （mockHof([1,2,3])）在 evaluateProgram 中求值并记录 call@ case——
+  // mock 晚于该点绑定会让「mock 函数值作为回调实参」整体降级 unknown。
+  it("top-level call site: items.map(fn) with a mock arrow yields precise elements", () => {
+    const result = analyzeFile("mock-hof-callsite.js", `
+// @nudo:mock fn = (x) => ({ ok: true, v: x })
+function mockHof(items) { return items.map(fn); }
+mockHof([1, 2, 3]);
+`);
+    const fn = result.functions.find((f) => f.name === "mockHof");
+    expect(fn).toBeDefined();
+    expect(fn!.cases[0].source).toBe("callsite");
+    expect(typeValueToString(fn!.cases[0].result)).toBe("[{ ok: true, v: 1 }, { ok: true, v: 2 }, { ok: true, v: 3 }]");
+  });
+
+  it("in-function call site: mock arrow through map/filter/reduce stays precise", () => {
+    const result = analyzeFile("mock-hof-inner.js", `
+// @nudo:mock fn = (x) => ({ ok: true, v: x })
+// @nudo:mock pred = (x) => x > 1
+// @nudo:mock add = (a, b) => a + b
+function innerMap(items) { return items.map(fn); }
+function innerFilter(xs) { return xs.filter(pred); }
+function innerReduce(xs) { return xs.reduce(add, 0); }
+const a = innerMap([1, 2]);
+const b = innerFilter([1, 2, 3]);
+const c = innerReduce([1, 2, 3]);
+`);
+    const map = result.functions.find((f) => f.name === "innerMap");
+    const filter = result.functions.find((f) => f.name === "innerFilter");
+    const reduce = result.functions.find((f) => f.name === "innerReduce");
+    expect(typeValueToString(map!.cases[0].result)).toBe("[{ ok: true, v: 1 }, { ok: true, v: 2 }]");
+    // filter 不丢元素类型
+    expect(typeValueToString(filter!.cases[0].result)).toBe("2 | 3[]");
+    expect(typeValueToString(reduce!.cases[0].result)).toBe("6");
+  });
+});

package/src/__tests__/mock-comparison.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect, beforeAll } from "vitest";
+import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+
+function runNudoTest(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Nudo vs TypeScript 对比测试", () => {
+  const source = `
+// 1. 数组处理管道
+// @nudo:mock validateItem = (item) => item !== null && item !== undefined
+// @nudo:mock transformItem = (item) => ({ ...item, processed: true })
+// @nudo:case "pipeline" ([{ id: 1 }, null, { id: 2 }, undefined, { id: 3 }])
+function processItems(items) {
+  return items
+    .filter(validateItem)
+    .map(transformItem);
+}
+
+// 2. 事件处理器
+// @nudo:mock handler = (event) => ({ type: event.type, handled: true })
+// @nudo:case "event" ({ type: "click", target: "button" })
+function dispatchEvent(event) {
+  const result = handler(event);
+  return { ...result, timestamp: Date.now() };
+}
+
+// 3. API 客户端
+// @nudo:mock httpClient = (url, options) => ({ status: 200, data: { success: true } })
+// @nudo:case "api" ("/api/users", { method: "GET" })
+function fetchUsers(url, options) {
+  const response = httpClient(url, options);
+  if (response.status === 200) {
+    return response.data;
+  }
+  return null;
+}
+
+// 4. 验证器组合
+// @nudo:mock isString = (v) => typeof v === "string"
+// @nudo:mock isNotEmpty = (v) => v.length > 0
+// @nudo:mock isEmail = (v) => v.includes("@")
+// @nudo:case "valid-email" ("user@example.com")
+// @nudo:case "empty" ("")
+// @nudo:case "number" (42)
+function validateEmail(value) {
+  if (!isString(value)) return { valid: false, error: "not a string" };
+  if (!isNotEmpty(value)) return { valid: false, error: "empty" };
+  if (!isEmail(value)) return { valid: false, error: "invalid format" };
+  return { valid: true, value };
+}
+
+// 5. 中间件链
+// @nudo:mock authMiddleware = (req) => ({ ...req, user: { id: 1 } })
+// @nudo:mock logMiddleware = (req) => req
+// @nudo:case "request" ({ path: "/api", method: "GET" })
+function applyMiddleware(req) {
+  let result = req;
+  result = authMiddleware(result);
+  result = logMiddleware(result);
+  return result;
+}
+
+// 6. 数据库查询构建器
+// @nudo:mock where = (field, op, value) => ({ field, op, value })
+// @nudo:mock orderBy = (field, dir) => ({ field, dir })
+// @nudo:case "query" ("age", ">", 18)
+function buildQuery(field, op, value) {
+  const condition = where(field, op, value);
+  const sort = orderBy("name", "asc");
+  return { conditions: [condition], sort };
+}
+
+// 7. 缓存装饰器
+// @nudo:mock fetchFromDB = (id) => ({ id, name: "User " + id, cached: false })
+// @nudo:case "user" (42)
+function getUserWithCache(id) {
+  const user = fetchFromDB(id);
+  return { ...user, cached: true };
+}
+
+// 8. 策略模式
+// @nudo:mock pricingStrategy = (base, quantity) => base * quantity * 0.9
+// @nudo:case "order" (100, 5)
+function calculatePrice(basePrice, quantity) {
+  return pricingStrategy(basePrice, quantity);
+}
+
+// 9. 异步操作
+// @nudo:mock asyncOperation = (data) => ({ result: data * 2 })
+// @nudo:case "async" (21)
+function processData(data) {
+  const result = asyncOperation(data);
+  return result;
+}
+
+// 10. 复杂嵌套
+// @nudo:mock outerFn = (x) => (y) => x + y
+// @nudo:case "curried" (10)
+function createAdder(x) {
+  const adder = outerFn(x);
+  return adder(5);
+}
+`;
+
+  let results: { name: string; caseName: string; result: string }[];
+
+  beforeAll(() => {
+    results = runNudoTest(source);
+  });
+
+  it("1. processItems - 数组处理管道", () => {
+    const r = results.find(r => r.caseName === "pipeline")!;
+    console.log("pipeline:", r.result);
+    expect(r.result).toContain("processed: true");
+  });
+
+  it("2. dispatchEvent - 事件处理", () => {
+    const r = results.find(r => r.caseName === "event")!;
+    console.log("event:", r.result);
+    expect(r.result).toContain("handled: true");
+  });
+
+  it("3. fetchUsers - API 调用", () => {
+    const r = results.find(r => r.caseName === "api")!;
+    console.log("api:", r.result);
+    expect(r.result).toContain("success: true");
+  });
+
+  it("4a. validateEmail - valid", () => {
+    const r = results.find(r => r.caseName === "valid-email")!;
+    console.log("valid-email:", r.result);
+    expect(r.result).toContain("valid: true");
+  });
+
+  it("4b. validateEmail - empty", () => {
+    const r = results.find(r => r.caseName === "empty")!;
+    console.log("empty:", r.result);
+    expect(r.result).toContain("valid: false");
+  });
+
+  it("4c. validateEmail - number", () => {
+    const r = results.find(r => r.caseName === "number")!;
+    console.log("number:", r.result);
+    expect(r.result).toContain("not a string");
+  });
+
+  it("5. applyMiddleware - 中间件", () => {
+    const r = results.find(r => r.caseName === "request")!;
+    console.log("request:", r.result);
+    expect(r.result).toContain("user:");
+  });
+
+  it("6. buildQuery - 查询构建", () => {
+    const r = results.find(r => r.caseName === "query")!;
+    console.log("query:", r.result);
+    expect(r.result).toContain("conditions:");
+  });
+
+  it("7. getUserWithCache - 缓存", () => {
+    const r = results.find(r => r.caseName === "user")!;
+    console.log("user:", r.result);
+    expect(r.result).toContain("cached: true");
+  });
+
+  it("8. calculatePrice - 策略", () => {
+    const r = results.find(r => r.caseName === "order")!;
+    console.log("order:", r.result);
+    expect(r.result).toBe("450");
+  });
+
+  it("9. processData - 数据处理", () => {
+    const r = results.find(r => r.caseName === "async")!;
+    console.log("async:", r.result);
+    expect(r.result).toContain("result: 42");
+  });
+
+  it("10. createAdder - 柯里化", () => {
+    const r = results.find(r => r.caseName === "curried")!;
+    console.log("curried:", r.result);
+    expect(r.result).toBe("15");
+  });
+
+  it("输出完整结果", () => {
+    console.log("\n=== Nudo @nudo:mock 测试结果 ===\n");
+    for (const r of results) {
+      console.log(`${r.name} - ${r.caseName}: ${r.result}`);
+    }
+    console.log(`\n总计: ${results.length} 个测试用例`);
+  });
+});

package/src/__tests__/mock-comprehensive.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect } from "vitest";
+import { parse, extractDirectives, type CaseDirective, parseTypeValueExpr } from "@nudojs/parser";
+import { typeValueToString, createEnvironment, T } from "@nudojs/core";
+import { evaluateFunctionFull } from "../evaluator.js";
+
+function inferWithMocks(source: string): { name: string; caseName: string; result: string }[] {
+  const ast = parse(source);
+  const directives = extractDirectives(ast);
+  const env = createEnvironment();
+  const results: { name: string; caseName: string; result: string }[] = [];
+
+  for (const fn of directives) {
+    // Apply mocks first
+    for (const d of fn.directives) {
+      if (d.kind === "mock") {
+        if (d.arrowFn) {
+          const fnType = T.fn(d.arrowFn.params, d.arrowFn.body, env);
+          (fnType as any)._paramPatterns = d.arrowFn.paramPatterns;
+          env.bind(d.name, fnType);
+        } else if (d.expression) {
+          env.bind(d.name, parseTypeValueExpr(d.expression));
+        }
+      }
+    }
+
+    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
+    for (const dir of caseDirectives) {
+      const result = evaluateFunctionFull(fn.node, dir.args, env);
+      results.push({
+        name: fn.name,
+        caseName: dir.name,
+        result: typeValueToString(result.value),
+      });
+    }
+  }
+  return results;
+}
+
+describe("Comprehensive Mock Tests", () => {
+  describe("Array method mocks", () => {
+    it("supports filter with mock predicate", () => {
+      const results = inferWithMocks(`
+// @nudo:mock isPositive = (x) => x > 0
+// @nudo:case "nums" ([-1, 2, -3, 4, -5])
+function filterPositive(arr) {
+  return arr.filter(isPositive);
+}
+`);
+      // filter returns a union type of elements that pass the predicate
+      expect(results[0].result).toBe("2 | 4[]");
+    });
+
+    it("supports map with mock transform", () => {
+      const results = inferWithMocks(`
+// @nudo:mock double = (x) => x * 2
+// @nudo:case "nums" ([1, 2, 3])
+function doubleAll(arr) {
+  return arr.map(double);
+}
+`);
+      expect(results[0].result).toBe("[2, 4, 6]");
+    });
+
+    it("supports reduce with mock reducer", () => {
+      const results = inferWithMocks(`
+// @nudo:mock add = (a, b) => a + b
+// @nudo:case "nums" ([1, 2, 3, 4])
+function sumAll(arr) {
+  return arr.reduce(add, 0);
+}
+`);
+      expect(results[0].result).toBe("10");
+    });
+
+    it("supports find with mock predicate", () => {
+      const results = inferWithMocks(`
+// @nudo:mock isEven = (x) => x % 2 === 0
+// @nudo:case "nums" ([1, 2, 3, 4, 5])
+function findFirstEven(arr) {
+  return arr.find(isEven);
+}
+`);
+      // find returns a union of all possible values plus undefined
+      expect(results[0].result).toBe("1 | 2 | 3 | 4 | 5 | undefined");
+    });
+
+    it("supports some with mock predicate", () => {
+      const results = inferWithMocks(`
+// @nudo:mock isNegative = (x) => x < 0
+// @nudo:case "nums" ([1, 2, 3])
+function hasNegative(arr) {
+  return arr.some(isNegative);
+}
+`);
+      expect(results[0].result).toBe("false");
+    });
+
+    it("supports every with mock predicate", () => {
+      const results = inferWithMocks(`
+// @nudo:mock isPositive = (x) => x > 0
+// @nudo:case "nums" ([1, 2, 3])
+function allPositive(arr) {
+  return arr.every(isPositive);
+}
+`);
+      expect(results[0].result).toBe("true");
+    });
+  });
+
+  describe("String method mocks", () => {
+    it("supports split with mock separator", () => {
+      const results = inferWithMocks(`
+// @nudo:mock separator = (x) => x === ","
+// @nudo:case "str" ("a,b,c")
+function splitByComma(str) {
+  return str.split(separator);
+}
+`);
+      // split with a function is not standard, but we test the mock mechanism
+      expect(results[0].result).toBeDefined();
+    });
+  });
+
+  describe("Higher-order function patterns", () => {
+    it("supports function composition", () => {
+      const results = inferWithMocks(`
+// @nudo:mock f = (x) => x + 1
+// @nudo:mock g = (x) => x * 2
+// @nudo:case "num" (5)
+function compose(x) {
+  return f(g(x));
+}
+`);
+      // g(5) = 10, f(10) = 11
+      expect(results[0].result).toBe("11");
+    });
+
+    it("supports function as return value", () => {
+      const results = inferWithMocks(`
+// @nudo:mock multiplier = (factor) => (x) => x * factor
+// @nudo:case "num" (5)
+function getDouble(x) {
+  const double = multiplier(2);
+  return double(x);
+}
+`);
+      // This tests that mock can return functions
+      expect(results[0].result).toBeDefined();
+    });
+
+    it("supports callback pattern", () => {
+      const results = inferWithMocks(`
+// @nudo:mock callback = (result) => result
+// @nudo:case "num" (42)
+function processWithCallback(x) {
+  const processed = x * 2;
+  return callback(processed);
+}
+`);
+      // callback(84) should return 84
+      expect(results[0].result).toBe("84");
+    });
+  });
+
+  describe("Multiple mock interactions", () => {
+    it("supports multiple mocks working together", () => {
+      const results = inferWithMocks(`
+// @nudo:mock predicate = (x) => x > 2
+// @nudo:mock transform = (x) => x * 10
+// @nudo:case "nums" ([1, 2, 3, 4, 5])
+function filterAndTransform(arr) {
+  const filtered = [];
+  for (const item of arr) {
+    if (predicate(item)) {
+      filtered.push(transform(item));
+    }
+  }
+  return filtered;
+}
+`);
+      // Filter items > 2: [3, 4, 5], then transform: [30, 40, 50]
+      expect(results[0].result).toBe("[30, 40, 50]");
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("handles mock with no parameters", () => {
+      const results = inferWithMocks(`
+// @nudo:mock getter = () => 42
+// @nudo:case "empty" ()
+function getValue() {
+  return getter();
+}
+`);
+      expect(results[0].result).toBe("42");
+    });
+
+    it("handles mock with rest parameters", () => {
+      const results = inferWithMocks(`
+// @nudo:mock sum = (...args) => args.length
+// @nudo:case "nums" ([1, 2, 3])
+function countArgs(arr) {
+  return sum(...arr);
+}
+`);
+      // Rest parameters collect all arguments into a tuple
+      expect(results[0].result).toBe("3");
+    });
+
+    it("handles mock with complex expressions", () => {
+      const results = inferWithMocks(`
+// @nudo:mock calc = (a, b) => (a + b) * (a - b)
+// @nudo:case "nums" (5, 3)
+function calculate(a, b) {
+  return calc(a, b);
+}
+`);
+      // calc(5, 3) = (5+3) * (5-3) = 8 * 2 = 16
+      expect(results[0].result).toBe("16");
+    });
+  });
+
+  describe("Integration with type narrowing", () => {
+    it("supports mock with typeof narrowing", () => {
+      const results = inferWithMocks(`
+// @nudo:mock processor = (x) => typeof x === "string" ? x.toUpperCase() : x
+// @nudo:case "str" ("hello")
+// @nudo:case "num" (42)
+function process(x) {
+  return processor(x);
+}
+`);
+      expect(results[0].result).toBe('"HELLO"');
+      expect(results[1].result).toBe("42");
+    });
+
+    it("supports mock with conditional logic", () => {
+      const results = inferWithMocks(`
+// @nudo:mock validator = (x) => x > 0 && x < 100
+// @nudo:case "valid" (50)
+// @nudo:case "invalid" (150)
+function validate(x) {
+  return validator(x);
+}
+`);
+      expect(results[0].result).toBe("true");
+      expect(results[1].result).toBe("false");
+    });
+  });
+});