Sample test fixtures

Author: stasm

resolver/src/ast.ts

@@ -8,6 +8,7 @@ export enum NodeType {
     Variant = "Variant",
     Pattern = "Pattern",
     Message = "Message",
+    GroupComment = "GroupComment",
     Resource = "Resource",
 }
 
@@ -71,7 +72,12 @@ export interface Message extends SyntaxNode {
     readonly value: Pattern | null;
 }
 
+export interface GroupComment extends SyntaxNode {
+    readonly type: NodeType.GroupComment;
+    readonly content: string;
+}
+
 export interface Resource extends SyntaxNode {
-    readonly type: NodeType.Message;
-    readonly body: Array<Message>;
+    readonly type: NodeType.Resource;
+    readonly body: Array<Message | GroupComment>;
 }

resolver/src/bin/format.ts

@@ -1,15 +1,16 @@
-import fs from "fs";
-import readline from "readline";
 import parseArgs from "minimist";
+import {fromStdin, fromFile} from "./input";
 import {Resource as ResourceParser} from "../lib/parser";
-import {Resource} from "../ast";
+import {Resource, NodeType, GroupComment} from "../ast";
 import {Bundle} from "../bundle";
 import {ErrorKind} from "../error";
+import {Value, StringValue, NumberValue} from "../value";
 
 const argv = parseArgs(process.argv.slice(2), {
-    boolean: ["help"],
+    boolean: ["help", "group"],
     alias: {
         help: "h",
+        group: "g",
     },
 });
 
@@ -20,32 +21,41 @@ if (argv.help) {
 const [filePath] = argv._;
 
 if (filePath === "-") {
-    parseStdin();
+    fromStdin(print);
 } else if (filePath) {
-    parseFile(filePath);
+    fromFile(filePath, print);
 } else {
     exitHelp(1);
 }
 
 function exitHelp(exitCode: number) {
     console.log(`
-    Usage: node --experimental-modules parse.mjs [OPTIONS] <FILE>
+    Usage: node format.js [OPTIONS] <FILE>
 
     When FILE is "-", read text from stdin.
 
     Examples:
 
-        node --experimental-modules parse.mjs path/to/file.ftl
-        cat path/to/file.ftl | node --experimental-modules parse.mjs -
+        node format.js path/to/file.ftl
+        cat path/to/file.ftl | node format.js -
 
     Options:
 
         -h, --help      Display help and quit.
+        -g, --group     Treat each group as a separate resource.
 `);
     process.exit(exitCode);
 }
 
-function parseFluent(source: string) {
+function print(source: string) {
+    if (argv.group) {
+        printGroups(source);
+    } else {
+        printAll(source);
+    }
+}
+
+function parseString(source: string) {
     return ResourceParser.run(source).fold(
         resource => resource,
         err => {
@@ -54,15 +64,20 @@ function parseFluent(source: string) {
     );
 }
 
-function format(resource: Resource) {
+type Variables = Map<string, Value>;
+
+function formatResource(resource: Resource, variables: Variables) {
     let bundle = new Bundle();
     bundle.addResource(resource);
 
     let results = [];
     for (let entry of resource.body) {
+        if (entry.type !== NodeType.Message) {
+            continue;
+        }
         let message = bundle.getMessage(entry.id.name);
         if (message) {
-            let {value, errors} = bundle.formatValue(message, new Map());
+            let {value, errors} = bundle.formatValue(message, variables);
             results.push({
                 value,
                 errors: errors.map(error => ({
@@ -72,36 +87,63 @@ function format(resource: Resource) {
             });
         }
     }
+    return results;
+}
 
+function printAll(source: string) {
+    let resource = parseString(source);
+    let results = formatResource(resource, new Map());
     console.log(JSON.stringify(results, null, 4));
 }
 
-function parseStdin() {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        prompt: "fluent>",
-    });
-
-    let lines: Array<string> = [];
-
-    rl.on("line", line => lines.push(line));
-    rl.on("close", () => parseFormat(lines.join("\n") + "\n"));
+interface Group {
+    resource: Resource;
+    variables: Map<string, Value>;
 }
 
-function parseFile(filePath: string) {
-    fs.readFile(filePath, "utf8", (err: NodeJS.ErrnoException | null, content: string | Buffer) => {
-        if (err) {
-            throw err;
+const RE_VARIABLE = /^\$([a-zA-Z]*): (string|number) = (.*)$/gm;
+function parseVariables(comment: GroupComment) {
+    let variables = new Map();
+    let match;
+    while ((match = RE_VARIABLE.exec(comment.content))) {
+        let [, name, type, value] = match;
+        switch (type) {
+            case "string":
+                variables.set(name, new StringValue(value));
+                break;
+            case "number":
+                variables.set(name, new NumberValue(parseFloat(value)));
+                break;
         }
+    }
+    return variables;
+}
+
+function printGroups(source: string) {
+    let resource = parseString(source);
 
-        if (typeof content === "string") {
-            parseFormat(content);
+    let groups: Array<Group> = [];
+    for (let entry of resource.body) {
+        if (entry.type === NodeType.GroupComment) {
+            groups.push({
+                resource: {
+                    type: NodeType.Resource,
+                    body: [],
+                },
+                variables: parseVariables(entry),
+            });
+        } else if (groups.length > 0) {
+            let currentGroup = groups[groups.length - 1];
+            currentGroup.resource.body.push(entry);
         }
-    });
-}
+    }
 
-function parseFormat(source: string) {
-    let resource = parseFluent(source);
-    format(resource);
+    let results = [];
+    for (let group of groups) {
+        let groupResults = formatResource(group.resource, group.variables);
+        let lastResult = groupResults.pop();
+        results.push(lastResult);
+    }
+
+    console.log(JSON.stringify(results, null, 4));
 }

resolver/src/bin/input.ts

@@ -0,0 +1,27 @@
+import fs from "fs";
+import readline from "readline";
+
+export function fromStdin(callback: (value: string) => void) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: "fluent>",
+    });
+
+    let lines: Array<string> = [];
+
+    rl.on("line", line => lines.push(line));
+    rl.on("close", () => callback(lines.join("\n") + "\n"));
+}
+
+export function fromFile(filePath: string, callback: (value: string) => void) {
+    fs.readFile(filePath, "utf8", (err: NodeJS.ErrnoException | null, content: string | Buffer) => {
+        if (err) {
+            throw err;
+        }
+
+        if (typeof content === "string") {
+            callback(content);
+        }
+    });
+}

resolver/src/bundle.ts

@@ -2,7 +2,7 @@ import {Scope} from "./scope";
 import {Value, NoneValue} from "./value";
 import {Message} from "./message";
 import {ScopeError} from "./error";
-import {Resource} from "./ast";
+import {Resource, NodeType} from "./ast";
 
 export interface Formatted {
     readonly value: string | null;
@@ -14,7 +14,9 @@ export class Bundle {
 
     addResource(resource: Resource) {
         for (let message of resource.body) {
-            this.messages.set(message.id.name, new Message(message));
+            if (message.type === NodeType.Message) {
+                this.messages.set(message.id.name, new Message(message));
+            }
         }
     }
 

resolver/test/fixtures/Makefile

@@ -0,0 +1,11 @@
+FTL_FIXTURES := $(wildcard *.ftl)
+AST_FIXTURES := $(FTL_FIXTURES:%.ftl=%.json)
+
+all: $(AST_FIXTURES)
+
+.PHONY: $(AST_FIXTURES)
+$(AST_FIXTURES): %.json: %.ftl
+	@node ../../dist/bin/format.js --group $< \
+		2> /dev/null \
+		1> $@;
+	@echo "$< → $@"

resolver/test/fixtures/message_reference.ftl

@@ -0,0 +1,4 @@
+##
+
+foo = Foo
+bar = {foo} Bar

resolver/test/fixtures/message_reference.json

@@ -0,0 +1,6 @@
+[
+    {
+        "value": "Foo Bar",
+        "errors": []
+    }
+]

resolver/test/fixtures/variable_reference.ftl

@@ -0,0 +1,8 @@
+## Unknown variable
+
+hello = Hello, {$world}!
+
+## Variable set to a string
+## $world: string = World
+
+hello = Hello, {$world}!

resolver/test/fixtures/variable_reference.json

@@ -0,0 +1,15 @@
+[
+    {
+        "value": "Hello, {$world}!",
+        "errors": [
+            {
+                "kind": "UnknownVariable",
+                "arg": "$world"
+            }
+        ]
+    },
+    {
+        "value": "Hello, World!",
+        "errors": []
+    }
+]