Bundle.formatPattern

Author: stasm

.eslintrc

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

.gitattributes

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

.prettierrc

@@ -0,0 +1,15 @@
+{
+    "editor.formatOnSave": false,
+    "[javascript]": {
+        "editor.formatOnSave": false
+    },
+    "[json]": {
+        "editor.formatOnSave": true
+    },
+    "[typescript]": {
+        "editor.formatOnSave": true
+    },
+    "editor.codeActionsOnSave": {
+        "source.organizeImports": true
+    }
+}

.vscode/settings.json

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

.vscode/tasks.json

@@ -52,8 +52,7 @@ function from_stdin() {
     const lines = [];
 
     rl.on("line", line => lines.push(line));
-    rl.on("close", () =>
-        print_ebnf(lines.join("\n") + "\n"));
+    rl.on("close", () => print_ebnf(lines.join("\n") + "\n"));
 }
 
 function from_file(file_path) {

bin/ebnf.js

@@ -0,0 +1,50 @@
+import parseArgs from "minimist";
+import {Resource} from "../format/resource";
+import {fromFile, fromStdin} from "../lib/input";
+import {formatResource} from "../lib/tools";
+
+const argv = parseArgs(process.argv.slice(2), {
+    boolean: ["help", "group"],
+    alias: {
+        help: "h",
+        group: "g",
+    },
+});
+
+if (argv.help) {
+    exitHelp(0);
+}
+
+const [filePath] = argv._;
+
+if (filePath === "-") {
+    fromStdin(print);
+} else if (filePath) {
+    fromFile(filePath, print);
+} else {
+    exitHelp(1);
+}
+
+function exitHelp(exitCode: number) {
+    console.log(`
+    Usage: node format.js [OPTIONS] <FILE>
+
+    When FILE is "-", read text from stdin.
+
+    Examples:
+
+        node format.js path/to/file.ftl
+        cat path/to/file.ftl | node format.js -
+
+    Options:
+
+        -h, --help      Display help and quit.
+`);
+    process.exit(exitCode);
+}
+
+function print(source: string) {
+    let resource = new Resource(source);
+    let results = formatResource(resource, new Map());
+    console.log(JSON.stringify(results, null, 4));
+}

bin/format.ts

@@ -52,8 +52,7 @@ function parse_stdin() {
     const lines = [];
 
     rl.on("line", line => lines.push(line));
-    rl.on("close", () =>
-        parse(lines.join("\n") + "\n"));
+    rl.on("close", () => parse(lines.join("\n") + "\n"));
 }
 
 function parse_file(file_path) {
@@ -66,9 +65,9 @@ function parse_file(file_path) {
     });
 }
 
-
 function parse(ftl) {
     Resource.run(ftl).fold(
         ast => console.log(JSON.stringify(ast, null, 4)),
-        err => console.error(err));
+        err => console.error(err)
+    );
 }

bin/parse.js

@@ -0,0 +1,93 @@
+export enum NodeType {
+    Identifer = "Identifier",
+    VariableReference = "VariableReference",
+    MessageReference = "MessageReference",
+    SelectExpression = "SelectExpression",
+    TextElement = "TextElement",
+    Placeable = "Placeable",
+    Variant = "Variant",
+    Pattern = "Pattern",
+    Message = "Message",
+    Attribute = "Attribute",
+    GroupComment = "GroupComment",
+    Resource = "Resource",
+}
+
+export interface SyntaxNode {
+    readonly type: NodeType;
+}
+
+export interface Identifier extends SyntaxNode {
+    readonly type: NodeType.Identifer;
+    readonly name: string;
+}
+
+export interface VariableReference extends SyntaxNode {
+    readonly type: NodeType.VariableReference;
+    readonly id: Identifier;
+}
+
+export interface MessageReference extends SyntaxNode {
+    readonly type: NodeType.MessageReference;
+    readonly id: Identifier;
+    readonly attribute: Identifier | null;
+}
+
+export interface SelectExpression extends SyntaxNode {
+    readonly type: NodeType.SelectExpression;
+    readonly selector: InlineExpression;
+    readonly variants: Array<Variant>;
+}
+
+export type InlineExpression = VariableReference | MessageReference;
+
+export type Expression = InlineExpression | SelectExpression;
+
+export interface TextElement extends SyntaxNode {
+    readonly type: NodeType.TextElement;
+    readonly value: string;
+}
+
+export interface Placeable extends SyntaxNode {
+    readonly type: NodeType.Placeable;
+    readonly expression: Expression;
+}
+
+export type PatternElement = TextElement | Placeable;
+
+export interface Variant extends SyntaxNode {
+    readonly type: NodeType.Variant;
+    readonly key: Identifier;
+    readonly value: Pattern;
+    readonly default: boolean;
+}
+
+export interface Pattern extends SyntaxNode {
+    readonly type: NodeType.Pattern;
+    readonly elements: Array<PatternElement>;
+}
+
+export interface Message extends SyntaxNode {
+    readonly type: NodeType.Message;
+    readonly id: Identifier;
+    readonly value: Pattern | null;
+    readonly attributes: Array<Attribute>;
+}
+
+export interface Attribute extends SyntaxNode {
+    readonly type: NodeType.Attribute;
+    readonly id: Identifier;
+    readonly value: Pattern;
+}
+
+export interface GroupComment extends SyntaxNode {
+    readonly type: NodeType.GroupComment;
+    readonly content: string;
+}
+
+export type Entry = Message | GroupComment;
+
+export interface Resource extends SyntaxNode {
+    readonly type: NodeType.Resource;
+    readonly body: Array<Entry>;
+}

format/ast.ts

@@ -0,0 +1,45 @@
+import {NodeType, Pattern} from "./ast";
+import {ScopeError} from "./error";
+import {Message} from "./message";
+import {Resource} from "./resource";
+import {Scope} from "./scope";
+import {Value} from "./value";
+
+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 === NodeType.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};
+    }
+}