Skip to content

Commit 4c345ea

Browse files
stasmstasm
committed
Remove VariableReference, SelectExpression
1 parent 1d08873 commit 4c345ea

File tree

4 files changed

+8
-194
lines changed

4 files changed

+8
-194
lines changed

‎format/ast.ts

Lines changed: 3 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,11 @@
11
export enum NodeType {
22
Identifer = "Identifier",
3-
VariableReference = "VariableReference",
43
MessageReference = "MessageReference",
5-
SelectExpression = "SelectExpression",
64
TextElement = "TextElement",
75
Placeable = "Placeable",
8-
Variant = "Variant",
96
Pattern = "Pattern",
107
Message = "Message",
118
Attribute = "Attribute",
12-
GroupComment = "GroupComment",
139
Resource = "Resource",
1410
}
1511

@@ -22,26 +18,15 @@ export interface Identifier extends SyntaxNode {
2218
readonly name: string;
2319
}
2420

25-
export interface VariableReference extends SyntaxNode {
26-
readonly type: NodeType.VariableReference;
27-
readonly id: Identifier;
28-
}
29-
3021
export interface MessageReference extends SyntaxNode {
3122
readonly type: NodeType.MessageReference;
3223
readonly id: Identifier;
3324
readonly attribute: Identifier | null;
3425
}
3526

36-
export interface SelectExpression extends SyntaxNode {
37-
readonly type: NodeType.SelectExpression;
38-
readonly selector: InlineExpression;
39-
readonly variants: Array<Variant>;
40-
}
41-
42-
export type InlineExpression = VariableReference | MessageReference;
27+
export type InlineExpression = MessageReference;
4328

44-
export type Expression = InlineExpression | SelectExpression;
29+
export type Expression = InlineExpression;
4530

4631
export interface TextElement extends SyntaxNode {
4732
readonly type: NodeType.TextElement;
@@ -55,13 +40,6 @@ export interface Placeable extends SyntaxNode {
5540

5641
export type PatternElement = TextElement | Placeable;
5742

58-
export interface Variant extends SyntaxNode {
59-
readonly type: NodeType.Variant;
60-
readonly key: Identifier;
61-
readonly value: Pattern;
62-
readonly default: boolean;
63-
}
64-
6543
export interface Pattern extends SyntaxNode {
6644
readonly type: NodeType.Pattern;
6745
readonly elements: Array<PatternElement>;
@@ -80,12 +58,7 @@ export interface Attribute extends SyntaxNode {
8058
readonly value: Pattern;
8159
}
8260

83-
export interface GroupComment extends SyntaxNode {
84-
readonly type: NodeType.GroupComment;
85-
readonly content: string;
86-
}
87-
88-
export type Entry = Message | GroupComment;
61+
export type Entry = Message;
8962

9063
export interface Resource extends SyntaxNode {
9164
readonly type: NodeType.Resource;

‎format/error.ts

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,4 @@
11
export enum ErrorKind {
2-
UnknownVariable,
32
UnknownMessage,
43
MissingValue,
54
}

‎format/scope.ts

Lines changed: 0 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -16,28 +16,13 @@ export class Scope {
1616

1717
resolveExpression(node: ast.Expression): Value {
1818
switch (node.type) {
19-
case ast.NodeType.VariableReference:
20-
return this.resolveVariableReference(node as ast.VariableReference);
2119
case ast.NodeType.MessageReference:
2220
return this.resolveMessageReference(node as ast.MessageReference);
23-
case ast.NodeType.SelectExpression:
24-
return this.resolveSelectExpression(node as ast.SelectExpression);
2521
default:
2622
throw new TypeError("Unknown node type.");
2723
}
2824
}
2925

30-
resolveVariableReference(node: ast.VariableReference): Value {
31-
let value = this.variables.get(node.id.name);
32-
if (value !== undefined) {
33-
return value;
34-
} else {
35-
let name = `$${node.id.name}`;
36-
this.errors.push(new ScopeError(ErrorKind.UnknownVariable, name));
37-
return new NoneValue(name);
38-
}
39-
}
40-
4126
resolveMessageReference(node: ast.MessageReference): Value {
4227
let message = this.messages.get(node.id.name);
4328
if (message == undefined) {
@@ -51,29 +36,6 @@ export class Scope {
5136
}
5237
}
5338

54-
resolveDefaultVariant(node: ast.SelectExpression): Value {
55-
for (let variant of node.variants) {
56-
if (variant.default) {
57-
return this.resolvePattern(variant.value);
58-
}
59-
}
60-
throw new RangeError("Missing default variant.");
61-
}
62-
63-
resolveSelectExpression(node: ast.SelectExpression): Value {
64-
let selector = this.resolveExpression(node.selector);
65-
if (selector instanceof NoneValue) {
66-
return this.resolveDefaultVariant(node);
67-
}
68-
69-
for (let variant of node.variants) {
70-
if (variant.key.name === selector.value) {
71-
return this.resolvePattern(variant.value);
72-
}
73-
}
74-
return this.resolveDefaultVariant(node);
75-
}
76-
7739
resolvePatternElement(node: ast.PatternElement): Value {
7840
switch (node.type) {
7941
case ast.NodeType.TextElement:

‎test/format/sample_test.ts

Lines changed: 5 additions & 125 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
import * as assert from "assert";
22
import {Bundle} from "../../format/bundle";
3-
import {ErrorKind, ScopeError} from "../../format/error";
43
import {Resource} from "../../format/resource";
5-
import {StringValue} from "../../format/value";
64

75
suite("Sample suite", function() {
86
let bundle: Bundle;
@@ -11,141 +9,23 @@ suite("Sample suite", function() {
119
bundle = new Bundle();
1210
bundle.addResource(
1311
new Resource(`
14-
hello = Hello, {$world}
12+
hello = Hello, world
1513
exclamation = {hello}!
16-
select = {$selector ->
17-
*[a] (a) {hello}
18-
[b] (b) {exclamation}
19-
}
2014
`)
2115
);
2216
});
2317

24-
test("hello with a variable", function() {
25-
let message = bundle.getMessage("hello");
26-
let {value, errors} = bundle.formatPattern(
27-
message!.value!,
28-
new Map(
29-
Object.entries({
30-
world: new StringValue("World"),
31-
})
32-
)
33-
);
34-
assert.equal(value, "Hello, World");
35-
assert.equal(errors.length, 0);
36-
});
37-
38-
test("hello without a variable", function() {
18+
test("hello", function() {
3919
let message = bundle.getMessage("hello");
4020
let {value, errors} = bundle.formatPattern(message!.value!, new Map());
41-
assert.equal(value, "Hello, {$world}");
42-
assert.equal(errors.length, 1);
43-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$world"));
44-
});
45-
46-
test("exclamation with a variable", function() {
47-
let message = bundle.getMessage("exclamation");
48-
let {value, errors} = bundle.formatPattern(
49-
message!.value!,
50-
new Map(
51-
Object.entries({
52-
world: new StringValue("World"),
53-
})
54-
)
55-
);
56-
assert.equal(value, "Hello, World!");
21+
assert.equal(value, "Hello, world");
5722
assert.equal(errors.length, 0);
5823
});
5924

60-
test("exclamation without a variable", function() {
25+
test("exclamation", function() {
6126
let message = bundle.getMessage("exclamation");
6227
let {value, errors} = bundle.formatPattern(message!.value!, new Map());
63-
assert.equal(value, "Hello, {$world}!");
64-
assert.equal(errors.length, 1);
65-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$world"));
66-
});
67-
68-
test("select [a] with a variable", function() {
69-
let message = bundle.getMessage("select");
70-
let {value, errors} = bundle.formatPattern(
71-
message!.value!,
72-
new Map(
73-
Object.entries({
74-
world: new StringValue("World"),
75-
selector: new StringValue("a"),
76-
})
77-
)
78-
);
79-
assert.equal(value, "(a) Hello, World");
80-
assert.equal(errors.length, 0);
81-
});
82-
83-
test("select [a] without a variable", function() {
84-
let message = bundle.getMessage("select");
85-
let {value, errors} = bundle.formatPattern(
86-
message!.value!,
87-
new Map(
88-
Object.entries({
89-
selector: new StringValue("a"),
90-
})
91-
)
92-
);
93-
assert.equal(value, "(a) Hello, {$world}");
94-
assert.equal(errors.length, 1);
95-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$world"));
96-
});
97-
98-
test("select [b] with a variable", function() {
99-
let message = bundle.getMessage("select");
100-
let {value, errors} = bundle.formatPattern(
101-
message!.value!,
102-
new Map(
103-
Object.entries({
104-
world: new StringValue("World"),
105-
selector: new StringValue("b"),
106-
})
107-
)
108-
);
109-
assert.equal(value, "(b) Hello, World!");
28+
assert.equal(value, "Hello, world!");
11029
assert.equal(errors.length, 0);
11130
});
112-
113-
test("select [b] without a variable", function() {
114-
let message = bundle.getMessage("select");
115-
let {value, errors} = bundle.formatPattern(
116-
message!.value!,
117-
new Map(
118-
Object.entries({
119-
selector: new StringValue("b"),
120-
})
121-
)
122-
);
123-
assert.equal(value, "(b) Hello, {$world}!");
124-
assert.equal(errors.length, 1);
125-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$world"));
126-
});
127-
128-
test("select default with a variable", function() {
129-
let message = bundle.getMessage("select");
130-
let {value, errors} = bundle.formatPattern(
131-
message!.value!,
132-
new Map(
133-
Object.entries({
134-
world: new StringValue("World"),
135-
})
136-
)
137-
);
138-
assert.equal(value, "(a) Hello, World");
139-
assert.equal(errors.length, 1);
140-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$selector"));
141-
});
142-
143-
test("select default without a variable", function() {
144-
let message = bundle.getMessage("select");
145-
let {value, errors} = bundle.formatPattern(message!.value!, new Map());
146-
assert.equal(value, "(a) Hello, {$world}");
147-
assert.equal(errors.length, 2);
148-
assert.deepEqual(errors[0], new ScopeError(ErrorKind.UnknownVariable, "$selector"));
149-
assert.deepEqual(errors[1], new ScopeError(ErrorKind.UnknownVariable, "$world"));
150-
});
15131
});

0 commit comments

Comments
 (0)