Formatting Specification Stub

.gitattributes

@@ -1,3 +1 @@
-*.ftl eol=lf
-test/fixtures/crlf.ftl eol=crlf
-test/fixtures/cr.ftl eol=cr
+**.ftl eol=lf

.gitignore

@@ -1,2 +1,3 @@
 node_modules
 build
+/format/**/*.js

.prettierrc

@@ -0,0 +1,6 @@
+{
+    "bracketSpacing": false,
+    "trailingComma": "es5",
+    "printWidth": 100,
+    "tabWidth": 4
+}

.travis.yml

@@ -1,7 +1,11 @@
 sudo: false
 language: node_js
+before_script: npm run build:impls
 script: npm run ci
-node_js: 9
+node_js:
+  - "8"
+  - "10"
+  - "12"
 cache:
   directories: node_modules
 notifications:

.vscode/settings.json

@@ -0,0 +1,19 @@
+{
+    "editor.formatOnSave": false,
+    "[javascript]": {
+        "editor.formatOnSave": false
+    },
+    "[json]": {
+        "editor.formatOnSave": true
+    },
+    "[typescript]": {
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.organizeImports": true
+        }
+    },
+    "files.exclude": {
+        "node_modules/": true,
+        "format/**/*.js": true
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,13 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "type": "npm",
+            "script": "watch",
+            "problemMatcher": [
+                "$tsc-watch"
+            ],
+            "isBackground": true
+        }
+    ]
+}

README.md

@@ -6,36 +6,56 @@ the natural language.
 This repository contains the specification, the reference implementation of the
 parser and the documentation for Fluent.
 
-## Fluent Syntax (FTL)
+## Fluent Syntax
 
 FTL is the syntax for describing translation resources in Project Fluent.  FTL
 stands for *Fluent Translation List*. Read the [Fluent Syntax Guide][] to get
 started learning Fluent.
 
-The `syntax/` directory contains the reference implementation of the syntax as
-a _LL(infinity)_ parser.
+The `syntax/spec` directory contains the formal EBNF grammar, autogenerated
+from the reference implementation.
+
+The `syntax/parser` directory contains the reference implementation of the
+syntax as a _LL(infinity)_ parser.
+
+## Fluent Format
+
+The `format/spec` directory contains the specification of formatting patterns
+into strings, including resolving all expressions in placeables.
+
+The `format/resolver` directory contains the reference implementation of
+`Bundle.formatPattern` and the resolver.
 
-The `spec/` directory contains the formal EBNF grammar, autogenerated from the
-reference implementation.
 
 ## Development
 
-While working on the reference parser, use the following commands to test and
-validate your work:
+The reference resolver is written in TypeScript and must be compiled before
+tests are run. The reference parser is currently still written in JavaScript.
+
+While working on the reference implementations, use the following commands to
+test and validate your work:
+
+    npm run watch              # Run the TypeScript compiler watcher.
+    npm test                   # Test the parser against JSON AST fixtures,
+                               # and test the resolver using the examples
+                               # from the spec (the resolver must be compiled).
 
-    npm test                   # Test the parser against JSON AST fixtures.
-    npm run lint               # Lint the parser code.
+    npm run lint               # Lint the parser and the resolver code.
+    npm run pretty             # Prettify the resolver code.
 
     npm run generate:ebnf      # Generate the EBNF from syntax/grammar.js.
     npm run generate:fixtures  # Generate test fixtures (FTL → JSON AST).
 
+    npm run build:impls        # Compile the resolver.
     npm run build:guide        # Build the HTML version of the Guide.
 
     npm run bench              # Run the performance benchmark on large FTL.
 
 ## Other Implementations
 
-This repository contains the reference implementation of the parser. Other implementations exist which should be preferred for use in production and in tooling.
+This repository contains the reference implementation of Fluent. Other
+implementations exist which should be preferred for use in production and in
+tooling.
 
   - The JavaScript implementation at [`fluent.js`](https://github.com/projectfluent/fluent.js), including the [React bindings](https://github.com/projectfluent/fluent.js/tree/master/fluent-react).
   - The Python implementation at [`python-fluent`](https://github.com/projectfluent/python-fluent).
@@ -49,8 +69,9 @@ We also know about the following community-driven implementations:
 
 ## Learn More and Discuss
 
-Find out more about Project Fluent at [projectfluent.org][] and discuss the future of Fluent at [Mozilla Discourse][].
+Find out more about Project Fluent at [projectfluent.org][] and discuss the
+future of Fluent at [Mozilla Discourse][].
 
-[Fluent Syntax Guide]: http://projectfluent.org/fluent/guide
-[projectfluent.org]: http://projectfluent.org
+[Fluent Syntax Guide]: https://projectfluent.org/fluent/guide
+[projectfluent.org]: https://projectfluent.org
 [Mozilla Discourse]: https://discourse.mozilla.org/c/fluent

format/lib/input.ts

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+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) {
+    return fs.readFileSync(filePath, "utf8");
+}
+
+export function* files(destination: string, ext: string) {
+    let files;
+    if (destination.endsWith(ext)) {
+        files = [destination];
+    } else {
+        files = fs
+            .readdirSync(destination)
+            .filter(filename => filename.endsWith(ext))
+            .map(filename => path.join(destination, filename));
+    }
+
+    for (let file of files) {
+        yield file;
+    }
+}

format/lib/tools.ts

@@ -0,0 +1,42 @@
+import {Bundle} from "../resolver/bundle.js";
+import {ErrorKind} from "../resolver/error.js";
+import {Resource} from "../resolver/resource.js";
+import {Value} from "../resolver/value.js";
+
+type Variables = Map<string, Value>;
+
+export function formatResource(resource: Resource, variables: Variables) {
+    let bundle = new Bundle();
+    bundle.addResource(resource);
+
+    let results = [];
+    for (let entry of resource.body) {
+        if (entry.type !== "Message") {
+            continue;
+        }
+        let message = bundle.getMessage(entry.id.name);
+        if (message) {
+            if (message.value) {
+                let {value, errors} = bundle.formatPattern(message.value, variables);
+                results.push({
+                    value,
+                    errors: errors.map(error => ({
+                        kind: ErrorKind[error.kind],
+                        arg: error.arg,
+                    })),
+                });
+            }
+        }
+    }
+    return results;
+}
+
+export function formatMessage(resource: Resource, variables: Variables, id: string) {
+    let bundle = new Bundle();
+    bundle.addResource(resource);
+
+    let message = bundle.getMessage(id);
+    if (message && message.value) {
+        return bundle.formatPattern(message.value, variables);
+    }
+}

format/lib/types.d.ts

@@ -0,0 +1,3 @@
+declare module "json-diff" {
+    export function diffString(actual: string, expected: string): string;
+}

format/lib/validate.ts

@@ -0,0 +1,35 @@
+import {deepStrictEqual} from "assert";
+import commonmark from "commonmark";
+import jsonDiff from "json-diff";
+
+type formatFn = (stdin: string) => string;
+
+export function validate(fn: formatFn, spec: string, source: string) {
+    // https://github.com/commonmark/commonmark.js/blob/master/README.md#usage
+    let reader = new commonmark.Parser();
+    let parsed = reader.parse(source);
+    let walker = parsed.walker();
+
+    let counter = 1;
+    let actual = null;
+    let current;
+    while ((current = walker.next())) {
+        let {entering, node} = current;
+        if (entering && node.type === "code_block" && node.literal !== null) {
+            if (node.info === "properties") {
+                actual = fn(node.literal);
+            } else if (node.info === "json" && actual) {
+                let expected = node.literal;
+
+                try {
+                    deepStrictEqual(JSON.parse(actual), JSON.parse(expected));
+                    console.log(`${spec} Example ${counter++} PASS`);
+                } catch (err) {
+                    console.log(`${spec} Example ${counter++} FAIL`);
+                    console.log(jsonDiff.diffString(err.actual, err.expected));
+                }
+                actual = null;
+            }
+        }
+    }
+}

format/resolver/bundle.ts

@@ -0,0 +1,45 @@
+import {Pattern} from "../../syntax/parser/ast.js";
+import {ScopeError} from "./error.js";
+import {Message} from "./message.js";
+import {Resource} from "./resource.js";
+import {Scope} from "./scope.js";
+import {Value} from "./value.js";
+
+export interface FormatResult {
+    readonly value: string;
+    readonly errors: Array<ScopeError>;
+}
+
+export class Bundle {
+    public readonly messages: Map<string, Message> = new Map();
+
+    addResource(resource: Resource) {
+        for (let message of resource.body) {
+            if (message.type === "Message") {
+                let attributes: Record<string, Pattern> = {};
+                for (let attribute of message.attributes) {
+                    attributes[attribute.id.name] = attribute.value;
+                }
+                this.messages.set(message.id.name, <Message>{
+                    id: message.id.name,
+                    value: message.value,
+                    attributes,
+                });
+            }
+        }
+    }
+
+    hasMessage(id: string) {
+        return this.messages.has(id);
+    }
+
+    getMessage(id: string) {
+        return this.messages.get(id);
+    }
+
+    formatPattern(pattern: Pattern, variables: Map<string, Value>): FormatResult {
+        let scope = new Scope(this.messages, variables);
+        let value = scope.resolvePattern(pattern).format(scope);
+        return {value, errors: scope.errors};
+    }
+}

format/resolver/error.ts

@@ -0,0 +1,15 @@
+export enum ErrorKind {
+    UnknownMessage,
+    MissingValue,
+}
+
+export class ScopeError extends Error {
+    public kind: ErrorKind;
+    public arg: string;
+
+    constructor(kind: ErrorKind, arg: string) {
+        super();
+        this.kind = kind;
+        this.arg = arg;
+    }
+}

format/resolver/message.ts

@@ -0,0 +1,7 @@
+import {Pattern} from "../../syntax/parser/ast.js";
+
+export interface Message {
+    readonly id: string;
+    readonly value: Pattern | null;
+    readonly attributes: Record<string, Pattern>;
+}

format/resolver/resource.ts

@@ -0,0 +1,19 @@
+import {Entry} from "../../syntax/parser/ast.js";
+import {Resource as ResourceParser} from "../../syntax/parser/grammar.js";
+
+export class Resource {
+    public readonly body: Array<Entry>;
+
+    constructor(source: string) {
+        this.body = this.parse(source).body;
+    }
+
+    private parse(source: string) {
+        return ResourceParser.run(source).fold(
+            resource => resource,
+            err => {
+                throw err;
+            }
+        );
+    }
+}