@weborigami/language 0.0.73 → 0.1.0

package/test/compiler/compile.test.js

@@ -77,11 +77,11 @@ describe("compile", () => {
         return strings[0] + values[0] + strings[1];
       },
     });
-    const fn = compile.expression("=tag`Hello, ${_}!`");
-    const templateFn = await fn.call(null);
-    const alice = await templateFn.call(scope, "Alice");
+    const program = compile.expression("=tag`Hello, ${_}!`");
+    const lambda = await program.call(scope);
+    const alice = await lambda("Alice");
     assert.equal(alice, "Hello, Alice!");
-    const bob = await templateFn.call(scope, "Bob");
+    const bob = await lambda("Bob");
     assert.equal(bob, "Hello, Bob!");
   });
 

package/test/compiler/parse.test.js

@@ -32,74 +32,38 @@ describe("Origami parser", () => {
       [ops.array, [ops.literal, 1]],
       [ops.array, [ops.literal, 2], [ops.literal, 3]],
     ]);
+    assertParse(
+      "array",
+      `[
+        1
+        2
+        3
+      ]`,
+      [ops.array, [ops.literal, 1], [ops.literal, 2], [ops.literal, 3]]
+    );
   });
 
-  test("expr", () => {
-    assertParse("expr", "obj.json", [ops.scope, "obj.json"]);
-    assertParse("expr", "(fn a, b, c)", [
-      [ops.scope, "fn"],
-      [ops.scope, "a"],
-      [ops.scope, "b"],
-      [ops.scope, "c"],
-    ]);
-    assertParse("expr", "foo.bar('hello', 'world')", [
-      [ops.scope, "foo.bar"],
-      [ops.literal, "hello"],
-      [ops.literal, "world"],
-    ]);
-    assertParse("expr", "(fn)('a')", [
-      [ops.scope, "fn"],
-      [ops.literal, "a"],
-    ]);
-    assertParse("expr", "1", [ops.literal, 1]);
-    assertParse("expr", "{ a: 1, b: 2 }", [
-      ops.object,
-      ["a", [ops.literal, 1]],
-      ["b", [ops.literal, 2]],
-    ]);
-    assertParse("expr", "serve { index.html: 'hello' }", [
-      [ops.scope, "serve"],
-      [ops.object, ["index.html", [ops.literal, "hello"]]],
-    ]);
-    assertParse("expr", "fn =`x`", [
-      [ops.scope, "fn"],
-      [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
-    ]);
-    assertParse("expr", "copy app(formulas), files 'snapshot'", [
-      [ops.scope, "copy"],
-      [
-        [ops.scope, "app"],
-        [ops.scope, "formulas"],
-      ],
-      [
-        [ops.scope, "files"],
-        [ops.literal, "snapshot"],
-      ],
-    ]);
-    assertParse("expr", "@map =`<li>${_}</li>`", [
-      [ops.scope, "@map"],
-      [
-        ops.lambda,
-        ["_"],
-        [
-          ops.template,
-          [ops.literal, ["<li>", "</li>"]],
-          [ops.concat, [ops.scope, "_"]],
-        ],
-      ],
+  test("callTarget", () => {
+    assertParse("callTarget", "foo", [ops.builtin, "foo"]);
+    assertParse("callTarget", "foo.js", [ops.scope, "foo.js"]);
+    assertParse("callTarget", "[1, 2]", [
+      ops.array,
+      [ops.literal, 1],
+      [ops.literal, 2],
     ]);
-    assertParse("expr", `"https://example.com"`, [
-      ops.literal,
-      "https://example.com",
+  });
+
+  test("doubleSlashPath", () => {
+    assertParse("doubleSlashPath", "//example.com", [
+      [ops.literal, "example.com"],
     ]);
-    assertParse("expr", "'Hello' -> test.orit", [
-      [ops.scope, "test.orit"],
-      [ops.literal, "Hello"],
+    assertParse("doubleSlashPath", "//example.com/index.html", [
+      [ops.literal, "example.com/"],
+      [ops.literal, "index.html"],
     ]);
-    assertParse("expr", "tag`Hello, ${name}!`", [
-      [ops.scope, "tag"],
-      [ops.literal, ["Hello, ", "!"]],
-      [ops.concat, [ops.scope, "name"]],
+    assertParse("doubleSlashPath", "//localhost:5000/foo", [
+      [ops.literal, "localhost:5000/"],
+      [ops.literal, "foo"],
     ]);
   });
 
@@ -109,7 +73,7 @@ describe("Origami parser", () => {
       `
         {
           index.html = index.ori(teamData.yaml)
-          thumbnails = @map(images, { value: thumbnail.js })
+          thumbnails = map(images, { value: thumbnail.js })
         }
       `,
       [
@@ -129,7 +93,7 @@ describe("Origami parser", () => {
           [
             ops.getter,
             [
-              [ops.scope, "@map"],
+              [ops.builtin, "map"],
               [ops.scope, "images"],
               [ops.object, ["value", [ops.scope, "thumbnail.js"]]],
             ],
@@ -138,44 +102,64 @@ describe("Origami parser", () => {
       ]
     );
 
+    // Builtin on its own is the function itself, not a function call
+    assertParse("expression", "mdHtml:", [ops.builtin, "mdHtml:"]);
+
     // Consecutive slahes in a path are removed
     assertParse("expression", "path//key", [
       ops.traverse,
       [ops.scope, "path/"],
       [ops.literal, "key"],
     ]);
+
     // Single slash at start of something = absolute file path
     assertParse("expression", "/path", [
       [ops.filesRoot],
       [ops.literal, "path"],
     ]);
+
     // Consecutive slashes at start of something = comment
     assertParse("expression", "path //comment", [ops.scope, "path"], false);
+    assertParse("expression", "page.ori(mdHtml:(about.md))", [
+      [ops.scope, "page.ori"],
+      [
+        [ops.builtin, "mdHtml:"],
+        [ops.scope, "about.md"],
+      ],
+    ]);
+
+    assertParse("expression", "'Hello' -> test.orit", [
+      [ops.scope, "test.orit"],
+      [ops.literal, "Hello"],
+    ]);
   });
 
   test("functionComposition", () => {
-    assertParse("functionComposition", "fn()", [[ops.scope, "fn"], undefined]);
-    assertParse("functionComposition", "fn(arg)", [
-      [ops.scope, "fn"],
+    assertParse("functionComposition", "fn()", [
+      [ops.builtin, "fn"],
+      undefined,
+    ]);
+    assertParse("functionComposition", "foo.js(arg)", [
+      [ops.scope, "foo.js"],
       [ops.scope, "arg"],
     ]);
     assertParse("functionComposition", "fn(a, b)", [
-      [ops.scope, "fn"],
+      [ops.builtin, "fn"],
       [ops.scope, "a"],
       [ops.scope, "b"],
     ]);
-    assertParse("functionComposition", "fn( a , b )", [
-      [ops.scope, "fn"],
+    assertParse("functionComposition", "foo.js( a , b )", [
+      [ops.scope, "foo.js"],
       [ops.scope, "a"],
       [ops.scope, "b"],
     ]);
     assertParse("functionComposition", "fn()(arg)", [
-      [[ops.scope, "fn"], undefined],
+      [[ops.builtin, "fn"], undefined],
       [ops.scope, "arg"],
     ]);
-    assertParse("functionComposition", "fn()/key", [
+    assertParse("functionComposition", "foo.js()/key", [
       ops.traverse,
-      [[ops.scope, "fn"], undefined],
+      [[ops.scope, "foo.js"], undefined],
       [ops.literal, "key"],
     ]);
     assertParse("functionComposition", "tree/key()", [
@@ -187,22 +171,22 @@ describe("Origami parser", () => {
       [ops.scope, "tree"],
     ]);
     assertParse("functionComposition", "fn()/key()", [
-      [ops.traverse, [[ops.scope, "fn"], undefined], [ops.literal, "key"]],
+      [ops.traverse, [[ops.builtin, "fn"], undefined], [ops.literal, "key"]],
       undefined,
     ]);
-    assertParse("functionComposition", "(fn())('arg')", [
-      [[ops.scope, "fn"], undefined],
+    assertParse("functionComposition", "(foo.js())('arg')", [
+      [[ops.scope, "foo.js"], undefined],
       [ops.literal, "arg"],
     ]);
     assertParse("functionComposition", "fn('a')('b')", [
       [
-        [ops.scope, "fn"],
+        [ops.builtin, "fn"],
         [ops.literal, "a"],
       ],
       [ops.literal, "b"],
     ]);
-    assertParse("functionComposition", "(fn())(a, b)", [
-      [[ops.scope, "fn"], undefined],
+    assertParse("functionComposition", "(foo.js())(a, b)", [
+      [[ops.scope, "foo.js"], undefined],
       [ops.scope, "a"],
       [ops.scope, "b"],
     ]);
@@ -212,53 +196,89 @@ describe("Origami parser", () => {
       [ops.literal, "b"],
     ]);
     assertParse("functionComposition", "fn arg", [
-      [ops.scope, "fn"],
+      [ops.builtin, "fn"],
       [ops.scope, "arg"],
     ]);
-    assertParse("functionComposition", "fn 'a', 'b'", [
-      [ops.scope, "fn"],
+    assertParse("functionComposition", "page.ori 'a', 'b'", [
+      [ops.scope, "page.ori"],
       [ops.literal, "a"],
       [ops.literal, "b"],
     ]);
     assertParse("functionComposition", "fn a(b), c", [
-      [ops.scope, "fn"],
+      [ops.builtin, "fn"],
       [
-        [ops.scope, "a"],
+        [ops.builtin, "a"],
         [ops.scope, "b"],
       ],
       [ops.scope, "c"],
     ]);
-    assertParse("functionComposition", "fn1 fn2 'arg'", [
-      [ops.scope, "fn1"],
+    assertParse("functionComposition", "foo.js bar.ori 'arg'", [
+      [ops.scope, "foo.js"],
       [
-        [ops.scope, "fn2"],
+        [ops.scope, "bar.ori"],
         [ops.literal, "arg"],
       ],
     ]);
     assertParse("functionComposition", "(fn()) 'arg'", [
-      [[ops.scope, "fn"], undefined],
+      [[ops.builtin, "fn"], undefined],
       [ops.literal, "arg"],
     ]);
     assertParse("functionComposition", "tree/key arg", [
       [ops.traverse, [ops.scope, "tree/"], [ops.literal, "key"]],
       [ops.scope, "arg"],
     ]);
-    assertParse("functionComposition", "https://example.com/tree.yaml 'key'", [
-      [ops.https, [ops.literal, "example.com"], [ops.literal, "tree.yaml"]],
-      [ops.literal, "key"],
+    assertParse("functionComposition", "new:(js:Date, '2025-01-01')", [
+      [ops.builtin, "new:"],
+      [
+        [ops.builtin, "js:"],
+        [ops.literal, "Date"],
+      ],
+      [ops.literal, "2025-01-01"],
+    ]);
+    assertParse("functionComposition", "map(markdown, mdHtml)", [
+      [ops.builtin, "map"],
+      [ops.scope, "markdown"],
+      [ops.scope, "mdHtml"],
     ]);
+    assertParse(
+      "functionComposition",
+      "package:@weborigami/dropbox/auth(creds)",
+      [
+        [
+          [ops.builtin, "package:"],
+          [ops.literal, "@weborigami/"],
+          [ops.literal, "dropbox/"],
+          [ops.literal, "auth"],
+        ],
+        [ops.scope, "creds"],
+      ]
+    );
+  });
+
+  test("functionReference", () => {
+    assertParse("functionReference", "json", [ops.builtin, "json"]);
+    assertParse("functionReference", "greet.js", [ops.scope, "greet.js"]);
   });
 
   test("group", () => {
     assertParse("group", "(hello)", [ops.scope, "hello"]);
     assertParse("group", "(((nested)))", [ops.scope, "nested"]);
-    assertParse("group", "(fn())", [[ops.scope, "fn"], undefined]);
+    assertParse("group", "(fn())", [[ops.builtin, "fn"], undefined]);
+    assertParse("group", "(a -> b)", [
+      [ops.builtin, "b"],
+      [ops.scope, "a"],
+    ]);
+  });
+
+  test("homeTree", () => {
+    assertParse("homeTree", "~", [ops.homeTree]);
   });
 
   test("host", () => {
     assertParse("host", "abc", [ops.literal, "abc"]);
     assertParse("host", "abc:123", [ops.literal, "abc:123"]);
     assertParse("host", "foo\\ bar", [ops.literal, "foo bar"]);
+    assertParse("host", "example.com/", [ops.literal, "example.com/"]);
   });
 
   test("identifier", () => {
@@ -283,6 +303,14 @@ describe("Origami parser", () => {
         [ops.concat, [ops.scope, "name"]],
       ],
     ]);
+    assertParse("lambda", "=indent`hello`", [
+      ops.lambda,
+      ["_"],
+      [
+        [ops.builtin, "indent"],
+        [ops.literal, ["hello"]],
+      ],
+    ]);
   });
 
   test("leadingSlashPath", () => {
@@ -324,10 +352,32 @@ describe("Origami parser", () => {
     assertParse("multiLineComment", "/*\nHello, world!\n*/", null, false);
   });
 
-  test("new", () => {
-    assertParse("expression", "new:@js/Date('2025-01-01')", [
-      [ops.constructor, [ops.literal, "@js"], [ops.literal, "Date"]],
-      [ops.literal, "2025-01-01"],
+  test("namespace", () => {
+    assertParse("namespace", "js:", [ops.builtin, "js:"]);
+  });
+
+  test("namespacePath", () => {
+    assertParse("namespacePath", "js:Date", [
+      [ops.builtin, "js:"],
+      [ops.literal, "Date"],
+    ]);
+    assertParse("namespacePath", "files:src/assets", [
+      [ops.builtin, "files:"],
+      [ops.literal, "src/"],
+      [ops.literal, "assets"],
+    ]);
+    assertParse("namespacePath", "foo://bar", [
+      [ops.builtin, "foo:"],
+      [ops.literal, "bar"],
+    ]);
+    assertParse("namespacePath", "http://example.com", [
+      [ops.builtin, "http:"],
+      [ops.literal, "example.com"],
+    ]);
+    assertParse("namespacePath", "https://example.com/foo/", [
+      [ops.builtin, "https:"],
+      [ops.literal, "example.com/"],
+      [ops.literal, "foo/"],
     ]);
   });
 
@@ -366,6 +416,18 @@ describe("Origami parser", () => {
       ["a", [ops.getter, [ops.scope, "b"]]],
       ["b", [ops.literal, 2]],
     ]);
+    assertParse(
+      "object",
+      `{
+        a = b
+        b = 2
+      }`,
+      [
+        ops.object,
+        ["a", [ops.getter, [ops.scope, "b"]]],
+        ["b", [ops.literal, 2]],
+      ]
+    );
     assertParse("object", "{ a: { b: 1 } }", [
       ops.object,
       ["a", [ops.object, ["b", [ops.literal, 1]]]],
@@ -376,16 +438,19 @@ describe("Origami parser", () => {
     ]);
     assertParse("object", "{ a: { b = fn() } }", [
       ops.object,
-      ["a/", [ops.object, ["b", [ops.getter, [[ops.scope, "fn"], undefined]]]]],
+      [
+        "a/",
+        [ops.object, ["b", [ops.getter, [[ops.builtin, "fn"], undefined]]]],
+      ],
     ]);
-    assertParse("object", "{ x = fn('a') }", [
+    assertParse("object", "{ x = fn.js('a') }", [
       ops.object,
       [
         "x",
         [
           ops.getter,
           [
-            [ops.scope, "fn"],
+            [ops.scope, "fn.js"],
             [ops.literal, "a"],
           ],
         ],
@@ -410,10 +475,10 @@ describe("Origami parser", () => {
       "a",
       [ops.lambda, ["a"], [ops.scope, "a"]],
     ]);
-    assertParse("objectEntry", "posts/: @map(posts, post.ori)", [
+    assertParse("objectEntry", "posts/: map(posts, post.ori)", [
       "posts/",
       [
-        [ops.scope, "@map"],
+        [ops.builtin, "map"],
         [ops.inherited, "posts"],
         [ops.scope, "post.ori"],
       ],
@@ -425,12 +490,12 @@ describe("Origami parser", () => {
       "data",
       [ops.getter, [ops.scope, "obj.json"]],
     ]);
-    assertParse("objectGetter", "foo = fn 'bar'", [
+    assertParse("objectGetter", "foo = page.ori 'bar'", [
       "foo",
       [
         ops.getter,
         [
-          [ops.scope, "fn"],
+          [ops.scope, "page.ori"],
           [ops.literal, "bar"],
         ],
       ],
@@ -446,7 +511,7 @@ describe("Origami parser", () => {
     assertParse("objectProperty", "x: fn('a')", [
       "x",
       [
-        [ops.scope, "fn"],
+        [ops.builtin, "fn"],
         [ops.literal, "a"],
       ],
     ]);
@@ -468,7 +533,7 @@ describe("Origami parser", () => {
       ops.lambda,
       ["a", "b", "c"],
       [
-        [ops.scope, "fn"],
+        [ops.builtin, "fn"],
         [ops.scope, "a"],
         [ops.scope, "b"],
         [ops.scope, "c"],
@@ -481,7 +546,7 @@ describe("Origami parser", () => {
         ops.lambda,
         ["b"],
         [
-          [ops.scope, "fn"],
+          [ops.builtin, "fn"],
           [ops.scope, "a"],
           [ops.scope, "b"],
         ],
@@ -516,8 +581,9 @@ describe("Origami parser", () => {
   });
 
   test("pipeline", () => {
+    assertParse("pipeline", "foo", [ops.scope, "foo"]);
     assertParse("pipeline", "a -> b", [
-      [ops.scope, "b"],
+      [ops.builtin, "b"],
       [ops.scope, "a"],
     ]);
     assertParse("pipeline", "input → one.js → two.js", [
@@ -528,33 +594,28 @@ describe("Origami parser", () => {
       ],
     ]);
     assertParse("pipeline", "fn a -> b", [
-      [ops.scope, "b"],
+      [ops.builtin, "b"],
       [
-        [ops.scope, "fn"],
+        [ops.builtin, "fn"],
         [ops.scope, "a"],
       ],
     ]);
   });
 
-  test("protocolCall", () => {
-    assertParse("protocolCall", "foo://bar", [
-      [ops.scope, "foo"],
-      [ops.literal, "bar"],
-    ]);
-    assertParse("protocolCall", "https://example.com/foo/", [
-      ops.https,
-      [ops.literal, "example.com"],
-      [ops.literal, "foo/"],
-    ]);
-    assertParse("protocolCall", "http:example.com", [
-      ops.http,
-      [ops.literal, "example.com"],
-    ]);
-    assertParse("protocolCall", "http://localhost:5000/foo", [
-      ops.http,
-      [ops.literal, "localhost:5000"],
-      [ops.literal, "foo"],
-    ]);
+  test("pipelineStep", () => {
+    assertParse("pipelineStep", "foo", [ops.builtin, "foo"]);
+    assertParse("pipelineStep", "=_", [ops.lambda, ["_"], [ops.scope, "_"]]);
+  });
+
+  test("program", () => {
+    assertParse(
+      "program",
+      `#!/usr/bin/env ori invoke
+'Hello'
+`,
+      [ops.literal, "Hello"],
+      false
+    );
   });
 
   test("scopeReference", () => {
@@ -577,17 +638,6 @@ describe("Origami parser", () => {
     ]);
   });
 
-  test("shebang", () => {
-    assertParse(
-      "expression",
-      `#!/usr/bin/env ori @invoke
-'Hello'
-`,
-      [ops.literal, "Hello"],
-      false
-    );
-  });
-
   test("singleLineComment", () => {
     assertParse("singleLineComment", "// Hello, world!", null, false);
   });
@@ -612,8 +662,12 @@ describe("Origami parser", () => {
   });
 
   test("taggedTemplate", () => {
-    assertParse("taggedTemplate", "tag`Hello, world.`", [
-      [ops.scope, "tag"],
+    assertParse("taggedTemplate", "indent`hello`", [
+      [ops.builtin, "indent"],
+      [ops.literal, ["hello"]],
+    ]);
+    assertParse("taggedTemplate", "fn.js`Hello, world.`", [
+      [ops.scope, "fn.js"],
       [ops.literal, ["Hello, world."]],
     ]);
   });
@@ -650,13 +704,13 @@ describe("Origami parser", () => {
       [ops.literal, ["", ""]],
       [ops.concat, [ops.template, [ops.literal, ["nested"]]]],
     ]);
-    assertParse("templateLiteral", "`${map(people, =`${name}`)}`", [
+    assertParse("templateLiteral", "`${ map:(people, =`${name}`) }`", [
       ops.template,
       [ops.literal, ["", ""]],
       [
         ops.concat,
         [
-          [ops.scope, "map"],
+          [ops.builtin, "map:"],
           [ops.scope, "people"],
           [
             ops.lambda,
@@ -689,6 +743,80 @@ describe("Origami parser", () => {
   });
 });
 
+test("value", () => {
+  assertParse("value", "obj.json", [ops.scope, "obj.json"]);
+  assertParse("value", "(fn a, b, c)", [
+    [ops.builtin, "fn"],
+    [ops.scope, "a"],
+    [ops.scope, "b"],
+    [ops.scope, "c"],
+  ]);
+  assertParse("value", "foo.bar('hello', 'world')", [
+    [ops.scope, "foo.bar"],
+    [ops.literal, "hello"],
+    [ops.literal, "world"],
+  ]);
+  assertParse("value", "(key)('a')", [
+    [ops.scope, "key"],
+    [ops.literal, "a"],
+  ]);
+  assertParse("value", "1", [ops.literal, 1]);
+  assertParse("value", "{ a: 1, b: 2 }", [
+    ops.object,
+    ["a", [ops.literal, 1]],
+    ["b", [ops.literal, 2]],
+  ]);
+  assertParse("value", "serve { index.html: 'hello' }", [
+    [ops.builtin, "serve"],
+    [ops.object, ["index.html", [ops.literal, "hello"]]],
+  ]);
+  assertParse("value", "fn =`x`", [
+    [ops.builtin, "fn"],
+    [ops.lambda, ["_"], [ops.template, [ops.literal, ["x"]]]],
+  ]);
+  assertParse("value", "copy app.js(formulas), files:snapshot", [
+    [ops.builtin, "copy"],
+    [
+      [ops.scope, "app.js"],
+      [ops.scope, "formulas"],
+    ],
+    [
+      [ops.builtin, "files:"],
+      [ops.literal, "snapshot"],
+    ],
+  ]);
+  assertParse("value", "map =`<li>${_}</li>`", [
+    [ops.builtin, "map"],
+    [
+      ops.lambda,
+      ["_"],
+      [
+        ops.template,
+        [ops.literal, ["<li>", "</li>"]],
+        [ops.concat, [ops.scope, "_"]],
+      ],
+    ],
+  ]);
+  assertParse("value", `"https://example.com"`, [
+    ops.literal,
+    "https://example.com",
+  ]);
+  assertParse("value", "tag`Hello, ${name}!`", [
+    [ops.builtin, "tag"],
+    [ops.literal, ["Hello, ", "!"]],
+    [ops.concat, [ops.scope, "name"]],
+  ]);
+  assertParse("value", "(post, slug) => fn.js(post, slug)", [
+    ops.lambda,
+    ["post", "slug"],
+    [
+      [ops.scope, "fn.js"],
+      [ops.scope, "post"],
+      [ops.scope, "slug"],
+    ],
+  ]);
+});
+
 function assertParse(startRule, source, expected, checkLocation = true) {
   const code = parse(source, {
     grammarSource: { text: source },
@@ -699,7 +827,7 @@ function assertParse(startRule, source, expected, checkLocation = true) {
   // entire source. We skip this check in cases where the source starts or ends
   // with a comment; the parser will strip those.
   if (checkLocation) {
-    assert(code.location);
+    assert(code.location, "no location");
     const resultSource = code.location.source.text.slice(
       code.location.start.offset,
       code.location.end.offset