@nudojs/cli 0.2.1 → 0.3.0

package/src/__tests__/evaluator-refined.test.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, typeValueToString, isSubtypeOf } from "@nudojs/core";
-import { isTemplate, getTemplateParts, isRange, getRangeMeta } from "@nudojs/core";
-import { evaluate, evaluateProgram } from "../evaluator.ts";
-import { createEnvironment } from "@nudojs/core";
-import { parse } from "@nudojs/parser";
-
-function evalExpr(code: string): import("@nudojs/core").TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  return evaluateProgram(ast, env);
-}
-
-function evalWithBindings(code: string, bindings: Record<string, import("@nudojs/core").TypeValue>): import("@nudojs/core").TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  for (const [k, v] of Object.entries(bindings)) {
-    env.bind(k, v);
-  }
-  return evaluateProgram(ast, env);
-}
-
-describe("Template Literal Evaluation", () => {
-  it("all-literal template produces literal", () => {
-    const result = evalExpr("`hello world`");
-    expect(typeValueEquals(result, T.literal("hello world"))).toBe(true);
-  });
-
-  it("template with abstract expression produces template type", () => {
-    const result = evalWithBindings("`xy${x}`", { x: T.string });
-    expect(isTemplate(result)).toBe(true);
-    expect(typeValueToString(result)).toBe("`xy${string}`");
-  });
-
-  it("template with multiple parts", () => {
-    const result = evalWithBindings("`${x}!`", { x: T.string });
-    expect(isTemplate(result)).toBe(true);
-    expect(typeValueToString(result)).toBe("`${string}!`");
-  });
-
-  it("string concatenation with + produces template", () => {
-    const result = evalWithBindings('"xy" + x', { x: T.string });
-    expect(isTemplate(result)).toBe(true);
-    expect(typeValueToString(result)).toBe("`xy${string}`");
-  });
-
-  it("chained concatenation produces template", () => {
-    const result = evalWithBindings('"x" + x + "!"', { x: T.string });
-    expect(isTemplate(result)).toBe(true);
-    expect(typeValueToString(result)).toBe("`x${string}!`");
-  });
-});
-
-describe("Template Method Dispatch", () => {
-  it("startsWith on template with known prefix returns true", () => {
-    const result = evalWithBindings(
-      'const s = "xy" + x; s.startsWith("x")',
-      { x: T.string },
-    );
-    // The evaluateMethodCall should dispatch to template's startsWith
-    // and return T.literal(true)
-    // Note: this requires string method support in evaluateMethodCall
-    // which we add in 6.1. For now, refined dispatch handles it.
-    if (result.kind === "literal") {
-      expect(result.value).toBe(true);
-    }
-  });
-});
-
-describe("Range Narrowing", () => {
-  it("x >= 0 narrows to range in true branch", () => {
-    const code = `
-      function f(x) {
-        if (x >= 0) {
-          return x;
-        }
-        return x;
-      }
-    `;
-    const ast = parse(code);
-    const env = createEnvironment();
-    evaluateProgram(ast, env);
-    const fn = env.lookup("f");
-    expect(fn.kind).toBe("function");
-  });
-
-  it("range comparison produces correct results", () => {
-    const result = evalWithBindings(
-      'const r = x >= 0 ? x : 0; r',
-      { x: T.number },
-    );
-    // In the true branch, x is narrowed to range(min:0)
-    // In the false branch, result is T.literal(0)
-    // Union of both
-    expect(result).toBeDefined();
-  });
-});
-
-describe("User-defined Refined Types", () => {
-  it("refined type with custom ops", () => {
-    const odd = T.refine(T.number, {
-      name: "odd",
-      meta: {},
-      ops: {
-        "%"(self, other) {
-          if (other.kind === "literal" && other.value === 2) return T.literal(1);
-          return undefined;
-        },
-      },
-    });
-
-    const result = evalWithBindings("x % 2", { x: odd });
-    expect(typeValueEquals(result, T.literal(1))).toBe(true);
-  });
-
-  it("refined type falls back to base for undefined ops", () => {
-    const odd = T.refine(T.number, { name: "odd", meta: {} });
-    const result = evalWithBindings("x + 1", { x: odd });
-    expect(typeValueEquals(result, T.number)).toBe(true);
-  });
-});

package/src/__tests__/evaluator-string-methods.test.ts

@@ -1,151 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, createEnvironment } from "@nudojs/core";
-import { evaluateProgram } from "../evaluator.ts";
-import { parse } from "@nudojs/parser";
-import type { TypeValue } from "@nudojs/core";
-
-function evalExpr(code: string): TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  return evaluateProgram(ast, env);
-}
-
-function evalWith(code: string, bindings: Record<string, TypeValue>): TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  for (const [k, v] of Object.entries(bindings)) env.bind(k, v);
-  return evaluateProgram(ast, env);
-}
-
-describe("String methods - literal receiver", () => {
-  it("toUpperCase", () => {
-    expect(typeValueEquals(evalExpr('"hello".toUpperCase()'), T.literal("HELLO"))).toBe(true);
-  });
-
-  it("toLowerCase", () => {
-    expect(typeValueEquals(evalExpr('"HELLO".toLowerCase()'), T.literal("hello"))).toBe(true);
-  });
-
-  it("trim", () => {
-    expect(typeValueEquals(evalExpr('"  hi  ".trim()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("trimStart", () => {
-    expect(typeValueEquals(evalExpr('"  hi".trimStart()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("trimEnd", () => {
-    expect(typeValueEquals(evalExpr('"hi  ".trimEnd()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("charAt", () => {
-    expect(typeValueEquals(evalExpr('"abc".charAt(1)'), T.literal("b"))).toBe(true);
-  });
-
-  it("charCodeAt", () => {
-    expect(typeValueEquals(evalExpr('"A".charCodeAt(0)'), T.literal(65))).toBe(true);
-  });
-
-  it("at", () => {
-    expect(typeValueEquals(evalExpr('"abc".at(-1)'), T.literal("c"))).toBe(true);
-  });
-
-  it("startsWith", () => {
-    expect(typeValueEquals(evalExpr('"hello".startsWith("he")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".startsWith("lo")'), T.literal(false))).toBe(true);
-  });
-
-  it("endsWith", () => {
-    expect(typeValueEquals(evalExpr('"hello".endsWith("lo")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".endsWith("he")'), T.literal(false))).toBe(true);
-  });
-
-  it("includes", () => {
-    expect(typeValueEquals(evalExpr('"hello".includes("ell")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".includes("xyz")'), T.literal(false))).toBe(true);
-  });
-
-  it("indexOf", () => {
-    expect(typeValueEquals(evalExpr('"hello".indexOf("l")'), T.literal(2))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".indexOf("z")'), T.literal(-1))).toBe(true);
-  });
-
-  it("lastIndexOf", () => {
-    expect(typeValueEquals(evalExpr('"hello".lastIndexOf("l")'), T.literal(3))).toBe(true);
-  });
-
-  it("slice", () => {
-    expect(typeValueEquals(evalExpr('"hello".slice(1, 3)'), T.literal("el"))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".slice(2)'), T.literal("llo"))).toBe(true);
-  });
-
-  it("substring", () => {
-    expect(typeValueEquals(evalExpr('"hello".substring(1, 4)'), T.literal("ell"))).toBe(true);
-  });
-
-  it("split", () => {
-    const result = evalExpr('"a,b,c".split(",")');
-    expect(result.kind).toBe("tuple");
-    if (result.kind === "tuple") {
-      expect(result.elements.length).toBe(3);
-      expect(typeValueEquals(result.elements[0], T.literal("a"))).toBe(true);
-      expect(typeValueEquals(result.elements[1], T.literal("b"))).toBe(true);
-      expect(typeValueEquals(result.elements[2], T.literal("c"))).toBe(true);
-    }
-  });
-
-  it("replace", () => {
-    expect(typeValueEquals(evalExpr('"hello".replace("l", "r")'), T.literal("herlo"))).toBe(true);
-  });
-
-  it("replaceAll", () => {
-    expect(typeValueEquals(evalExpr('"hello".replaceAll("l", "r")'), T.literal("herro"))).toBe(true);
-  });
-
-  it("repeat", () => {
-    expect(typeValueEquals(evalExpr('"ab".repeat(3)'), T.literal("ababab"))).toBe(true);
-  });
-
-  it("padStart", () => {
-    expect(typeValueEquals(evalExpr('"5".padStart(3, "0")'), T.literal("005"))).toBe(true);
-  });
-
-  it("padEnd", () => {
-    expect(typeValueEquals(evalExpr('"5".padEnd(3, "0")'), T.literal("500"))).toBe(true);
-  });
-});
-
-describe("String methods - abstract receiver", () => {
-  it("toUpperCase returns string", () => {
-    const result = evalWith("x.toUpperCase()", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-
-  it("startsWith returns boolean", () => {
-    const result = evalWith('x.startsWith("a")', { x: T.string });
-    expect(typeValueEquals(result, T.boolean)).toBe(true);
-  });
-
-  it("indexOf returns number", () => {
-    const result = evalWith('x.indexOf("a")', { x: T.string });
-    expect(typeValueEquals(result, T.number)).toBe(true);
-  });
-
-  it("split returns string[]", () => {
-    const result = evalWith('x.split(",")', { x: T.string });
-    expect(result.kind).toBe("array");
-    if (result.kind === "array") {
-      expect(typeValueEquals(result.element, T.string)).toBe(true);
-    }
-  });
-
-  it("charAt returns string", () => {
-    const result = evalWith("x.charAt(0)", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-
-  it("slice returns string", () => {
-    const result = evalWith("x.slice(1)", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-});