@wq2/brigadier-ts 1.0.0

package/src/exceptions/CommandSyntaxError.ts

@@ -0,0 +1,48 @@
+import { CommandErrorType } from "..";
+
+const CONTEXT_AMOUNT = 10;
+
+export class CommandSyntaxError extends Error {
+    private input: string;
+    private cursor: number;
+
+    constructor(message: string, input?: string, cursor?: number) {
+        super(message);
+        Object.setPrototypeOf(this, CommandSyntaxError.prototype);
+        this.input = input;
+        this.cursor = cursor;
+
+        if (input && cursor >= 0) {
+            this.message += ` at position ${cursor}: `;
+            const cursor2 = Math.min(this.input.length, this.cursor);
+            this.message += cursor > CONTEXT_AMOUNT ? "..." : "";
+            this.message += this.input.substring(Math.max(0, cursor2 - CONTEXT_AMOUNT), cursor2);
+            this.message += "<--[HERE]";
+        }
+    }
+
+    static DOUBLE_TOO_SMALL = new CommandErrorType((found, min) => `Double must not be less than ${min}, found ${found}`);
+    static DOUBLE_TOO_BIG = new CommandErrorType((found, max) => `Double must not be more than ${max}, found ${found}`);
+    static FLOAT_TOO_SMALL = new CommandErrorType((found, min) => `Float must not be less than ${min}, found ${found}`);
+    static FLOAT_TOO_BIG = new CommandErrorType((found, max) => `Float must not be more than ${max}, found ${found}`);
+    static INTEGER_TOO_SMALL = new CommandErrorType((found, min) => `Integer must not be less than ${min}, found ${found}`);
+    static INTEGER_TOO_BIG = new CommandErrorType((found, max) => `Integer must not be more than ${max}, found ${found}`);
+    static LONG_TOO_SMALL = new CommandErrorType((found, min) => `Long must not be less than ${min}, found ${found}`);
+    static LONG_TOO_BIG = new CommandErrorType((found, max) => `Long must not be more than ${max}, found ${found}`);
+    static LITERAL_INCORRECT = new CommandErrorType((expected) => `Expected literal ${expected}`);
+
+    static READER_EXPECTED_START_OF_QUOTE = new CommandErrorType(() => `Expected quote to start a string`);
+    static READER_EXPECTED_END_OF_QUOTE = new CommandErrorType(() => `Unclosed quoted string`);
+    static READER_INVALID_ESCAPE = new CommandErrorType((character) => `Invalid escape sequence '${character}' in quoted string`);
+    static READER_INVALID_BOOL = new CommandErrorType((value) => `Invalid bool, expected true or false but found '${value}'`);
+    static READER_EXPECTED_BOOL = new CommandErrorType(() => `Expected bool`);
+    static READER_INVALID_INT = new CommandErrorType((value) => `Invalid integer '${value}'`);
+    static READER_EXPECTED_INT = new CommandErrorType(() => `Expected integer`);
+    static READER_INVALID_FLOAT = new CommandErrorType((value) => `Invalid float '${value}'`);
+    static READER_EXPECTED_FLOAT = new CommandErrorType(() => `Expected float`);
+
+    static DISPATCHER_UNKNOWN_COMMAND = new CommandErrorType(() => `Unknown Command`);
+    static DISPATCHER_UNKNOWN_ARGUMENT = new CommandErrorType(() => `Incorrect argument for command`);
+    static DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR = new CommandErrorType(() => `Expected whitespace to end one argument, but found trailing data`);
+    static DISPATCHER_PARSE_ERROR = new CommandErrorType((message) => `Could not parse command: ${message}`);
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export * from "./Command"
+export * from "./Predicate"
+export * from "./context/StringRange"
+export * from "./exceptions/CommandErrorType"
+export * from "./exceptions/CommandSyntaxError"
+export * from "./StringReader"
+export * from "./suggestion/Suggestion"
+export * from "./suggestion/Suggestions"
+export * from "./suggestion/SuggestionsBuilder"
+export * from "./tree/CommandNode"
+export * from "./tree/LiteralCommandNode"
+export * from "./tree/ArgumentCommandNode"
+export * from "./tree/RootCommandNode"
+export * from "./arguments/ArgumentType"
+export * from "./arguments/NumberArgumentType"
+export * from "./arguments/FloatArgumentType"
+export * from "./arguments/IntegerArgumentType"
+export * from "./arguments/LongArgumentType"
+export * from "./arguments/BoolArgumentType"
+export * from "./arguments/StringArgumentType"
+export * from "./builder/ArgumentBuilder"
+export * from "./builder/LiteralArgumentBuilder"
+export * from "./builder/RequiredArgumentBuilder"
+export * from "./context/ParsedArgument"
+export * from "./context/ParsedCommandNode"
+export * from "./context/CommandContext"
+export * from "./context/CommandContextBuilder"
+export * from "./context/SuggestionContext"
+export * from "./ParseResults"
+export * from "./CommandDispatcher"

package/src/suggestion/Suggestion.ts

@@ -0,0 +1,55 @@
+import { StringRange } from "..";
+
+export class Suggestion {
+    private range: StringRange;
+    private text: string;
+    private tooltip: string;
+
+    constructor(range: StringRange, text: string, tooltip?: string) {
+        this.range = range;
+        this.text = text;
+        this.tooltip = tooltip;
+    }
+
+    getRange() {
+        return this.range;
+    }
+
+    getText() {
+        return this.text;
+    }
+
+    getTooltip() {
+        return this.tooltip;
+    }
+
+    apply(input: string): string {
+        if (this.range.getStart() == 0 && this.range.getEnd() === input.length) {
+            return this.text;
+        }
+        let result = "";
+        if (this.range.getStart() > 0) {
+            result += input.substring(0, this.range.getStart());
+        }
+        result += this.text;
+        if (this.range.getEnd() < input.length) {
+            result += input.substring(this.range.getEnd());
+        }
+        return result;
+    }
+
+    expand(command: string, range: StringRange): Suggestion {
+        if (range === this.range) {
+            return this;
+        }
+        let result = "";
+        if (range.getStart() < this.range.getStart()) {
+            result += command.substring(range.getStart(), this.range.getStart());
+        }
+        result += this.text;
+        if (range.getEnd() > this.range.getEnd()) {
+            result += command.substring(this.range.getEnd(), range.getEnd());
+        }
+        return new Suggestion(range, result, this.tooltip);
+    }
+}

package/src/suggestion/Suggestions.ts

@@ -0,0 +1,60 @@
+import { StringRange, Suggestion } from "..";
+
+export class Suggestions {
+    static EMPTY = new Suggestions(StringRange.at(0), []);
+
+    private range: StringRange;
+    private suggestions: Suggestion[];
+
+    constructor(range: StringRange, suggestions: Suggestion[]) {
+        this.range = range;
+        this.suggestions = suggestions;
+    }
+
+    getRange(): StringRange {
+        return this.range;
+    }
+
+    getList(): Suggestion[] {
+        return this.suggestions;
+    }
+
+    isEmpty(): boolean {
+        return this.suggestions.length === 0;
+    }
+
+    static empty(): Promise<Suggestions> {
+        return Promise.resolve(Suggestions.EMPTY);
+    }
+
+    static merge(command: string, input: Suggestions[]): Suggestions {
+        if (input.length === 0) {
+            return Suggestions.EMPTY;
+        } else if (input.length === 1) {
+            return input[0];
+        }
+        const texts = new Set<Suggestion>();
+        for (const suggestions of input) {
+            suggestions.getList().forEach(s => texts.add(s))
+        }
+        return Suggestions.create(command, Array.from(texts));
+    }
+
+    static create(command: string, suggestions: Suggestion[]): Suggestions {
+        if (suggestions.length === 0) {
+            return Suggestions.EMPTY;
+        }
+        let start = Infinity;
+        let end = -Infinity;
+        for (const suggestion of suggestions) {
+            start = Math.min(suggestion.getRange().getStart(), start);
+            end = Math.max(suggestion.getRange().getEnd(), end);
+        }
+        const range = new StringRange(start, end);
+        const texts = [];
+        for (const suggestion of suggestions) {
+            texts.push(suggestion.expand(command, range));
+        }
+        return new Suggestions(range, texts.sort());
+    }
+}

package/src/suggestion/SuggestionsBuilder.ts

@@ -0,0 +1,60 @@
+import { 
+    Suggestion,
+    Suggestions,
+    StringRange
+} from "..";
+
+export class SuggestionsBuilder {
+    private input: string;
+    private start: number;
+    private remaining: string;
+    private result: Suggestion[];
+
+    constructor(input: string, start: number) {
+        this.input = input;
+        this.start = start;
+        this.remaining = input.substring(start);
+        this.result = [];
+    }
+
+    getInput(): string {
+        return this.input;
+    }
+
+    getStart(): number {
+        return this.start;
+    }
+
+    getRemaining(): string {
+        return this.remaining;
+    }
+
+    build(): Suggestions {
+        return Suggestions.create(this.input, this.result);
+    }
+
+    buildPromise(): Promise<Suggestions> {
+        return Promise.resolve(this.build());
+    }
+
+    suggest(text: string, tooltip?: string): SuggestionsBuilder {
+        if (text === this.remaining) {
+            return this;
+        }
+        this.result.push(new Suggestion(new StringRange(this.start, this.input.length), text, tooltip))
+        return this;
+    }
+
+    add(other: SuggestionsBuilder): SuggestionsBuilder {
+        this.result.concat(other.result);
+        return this;
+    }
+
+    createOffset(start: number): SuggestionsBuilder {
+        return new SuggestionsBuilder(this.input, start);
+    }
+
+    restart(start: number): SuggestionsBuilder {
+        return new SuggestionsBuilder(this.input, this.start);
+    }
+}

package/src/tree/ArgumentCommandNode.ts

@@ -0,0 +1,48 @@
+import {
+    ArgumentType,
+    CommandNode,
+    StringReader,
+    Command,
+    CommandContext,
+    CommandContextBuilder,
+    Predicate,
+    RedirectModifier,
+    ParsedArgument,
+    Suggestions,
+    SuggestionsBuilder
+} from '..';
+
+export class ArgumentCommandNode<S, T> extends CommandNode<S> {
+    name: string;
+    type: ArgumentType<T>;
+
+    constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
+        super(command, requirement, redirect, modifier, forks);
+        this.name = name;
+        this.type = type;
+    }
+
+    getType(): ArgumentType<T> {
+        return this.type;
+    }
+
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
+        const start = reader.getCursor();
+        const result = this.type.parse(reader);
+        const parsed = new ParsedArgument<T>(start, reader.getCursor(), result);
+        contextBuilder.withArgument(this.name, parsed);
+        contextBuilder.withNode(this, parsed.getRange());
+    }
+    
+    getName(): string {
+        return this.name;
+    }
+
+    getUsageText(): string {
+        return "<" + this.name + ">";
+    }
+    
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
+        return Suggestions.empty();
+    }
+}

package/src/tree/CommandNode.ts

@@ -0,0 +1,105 @@
+import {
+    StringReader,
+    Command,
+    LiteralCommandNode,
+    ArgumentCommandNode,
+    CommandContext,
+    CommandContextBuilder,
+    Predicate,
+    RedirectModifier,
+    SuggestionsBuilder,
+    Suggestions
+} from '..';
+
+export abstract class CommandNode<S> {
+    private children: Map<string, CommandNode<S>>;
+    private literals: Map<string, LiteralCommandNode<S>>;
+    private arguments: Map<string, ArgumentCommandNode<S, any>>;
+    private command: Command<S>;
+    private requirement: Predicate<S>;
+    private redirect: CommandNode<S>;
+    private modifier: RedirectModifier<S>;
+    private forks: boolean;
+
+    constructor(command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
+        this.children = new Map();
+        this.literals = new Map();
+        this.arguments = new Map();
+        this.command = command;
+        this.requirement = requirement;
+        this.redirect = redirect;
+        this.modifier = modifier;
+        this.forks = forks;
+    }
+
+    getCommand(): Command<S> {
+        return this.command;
+    }
+
+    getChildren(): CommandNode<S>[] {
+        return Array.from(this.children.values());
+    }
+
+    getChild(name: string): CommandNode<S> {
+        return this.children.get(name);
+    }
+
+    getRedirect(): CommandNode<S> {
+        return this.redirect;
+    }
+
+    getRedirectModifier(): RedirectModifier<S> {
+        return this.modifier;
+    }
+
+    isFork(): boolean {
+        return this.forks;
+    }
+
+    canUse(source: S) {
+        return this.requirement(source);
+    }
+
+    addChild(node: CommandNode<S>): void {
+        const child = this.children.get(node.getName());
+        if (child != null) {
+            if (node.getCommand() != null) {
+                child.command = node.getCommand();
+            }
+            node.getChildren().forEach((grandChild) => {
+                child.addChild(grandChild);
+            });
+        } else {
+            this.children.set(node.getName(), node);
+            if (node instanceof LiteralCommandNode) {
+                this.literals.set(node.getName(), node);
+            } else if (node instanceof ArgumentCommandNode) {
+                this.arguments.set(node.getName(), node);
+            }
+        }
+    }
+
+    abstract parse(reader: StringReader, context: CommandContextBuilder<S>): void;
+
+    abstract getName(): string;
+
+    abstract getUsageText(): string;
+
+    abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
+
+    getRelevantNodes(input: StringReader): CommandNode<S>[] {
+        if (this.literals.size > 0) {
+            const cursor = input.getCursor();
+            while (input.canRead() && input.peek() != " ") {
+                input.skip();
+            }
+            const text = input.getString().substring(cursor, input.getCursor());
+            input.setCursor(cursor);
+            const literal = this.literals.get(text);
+            if (literal != null) {
+                return [literal];
+            }
+        }
+        return Array.from(this.arguments.values());
+    }
+}

package/src/tree/LiteralCommandNode.ts

@@ -0,0 +1,64 @@
+import { 
+    CommandNode,
+    StringReader,
+    Command,
+    StringRange,
+    CommandContext,
+    CommandContextBuilder,
+    Predicate,
+    RedirectModifier,
+    CommandSyntaxError,
+    Suggestions,
+    SuggestionsBuilder
+} from '..';
+
+export class LiteralCommandNode<S> extends CommandNode<S> {
+    private literal: string;
+    
+    constructor(literal: string, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
+        super(command, requirement, redirect, modifier, forks);
+        this.literal = literal;
+    }
+
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
+        const start = reader.getCursor();
+        const end = this.parseInternal(reader);
+        if (end > -1) {
+            contextBuilder.withNode(this, new StringRange(start, end));
+            return;
+        }
+        throw CommandSyntaxError.LITERAL_INCORRECT.createWithContext(reader, this.literal);
+    }
+
+    private parseInternal(reader: StringReader): number {
+        const start = reader.getCursor();
+        if (reader.canRead(this.literal.length)) {
+            const end = start + this.literal.length;
+            if (reader.getString().substr(start, this.literal.length) === this.literal) {
+                reader.setCursor(end);
+                if (!reader.canRead() || reader.peek() == " ") {
+                    return end;
+                } else {
+                    reader.setCursor(start);
+                }
+            }
+        }
+        return -1;
+    }
+    
+    getName(): string {
+        return this.literal;
+    }
+
+    getUsageText(): string {
+        return this.literal;
+    }
+
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
+        if (this.literal.toLowerCase().startsWith(builder.getRemaining().toLowerCase())) {
+            return builder.suggest(this.literal).buildPromise();
+        } else {
+            return Suggestions.empty();
+        }
+    }
+}

package/src/tree/RootCommandNode.ts

@@ -0,0 +1,30 @@
+import { 
+    CommandNode,
+    StringReader,
+    CommandContextBuilder,
+    CommandContext,
+    Suggestions,
+    SuggestionsBuilder
+} from '..';
+
+export class RootCommandNode<S> extends CommandNode<S> {
+
+    constructor() {
+        super(null, async c => true, null, c => null, false);
+    }
+
+    parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void {
+    }
+
+    getName(): string {
+        return "";
+    }
+
+    getUsageText(): string {
+        return "";
+    }
+
+    listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
+        return Suggestions.empty();
+    }
+}

package/test/Arguments.test.ts

@@ -0,0 +1,36 @@
+import { argument, CommandDispatcher, FloatArgumentType, IntegerArgumentType, literal, LongArgumentType } from '../src'
+
+describe('Arguments', () => {
+	test('Integer', async () => {
+		const dispatcher = new CommandDispatcher()
+		dispatcher.register(literal('foo')
+			.then(argument('bar', new IntegerArgumentType())
+				.executes(async ctx => ctx.get('bar') * 2)
+			)
+		)
+		const result = await dispatcher.execute('foo 6', undefined)
+		expect(result).toEqual(12)
+	})
+
+	test('Long', async () => {
+		const dispatcher = new CommandDispatcher()
+		dispatcher.register(literal('foo')
+			.then(argument('bar', new LongArgumentType())
+				.executes(async ctx => ctx.get('bar').toString().length)
+			)
+		)
+		const result = await dispatcher.execute('foo 123456789012345', undefined)
+		expect(result).toEqual(15)
+	})
+
+	test('Float', async () => {
+		const dispatcher = new CommandDispatcher()
+		dispatcher.register(literal('foo')
+			.then(argument('bar', new FloatArgumentType())
+				.executes(async ctx => Math.floor(ctx.get('bar')))
+			)
+		)
+		const result = await dispatcher.execute('foo 6.2', undefined)
+		expect(result).toEqual(6)
+	})
+})

package/test/CommandDispatcher.test.ts

@@ -0,0 +1,25 @@
+import { CommandDispatcher, literal } from '../src'
+
+describe('CommandDispatcher', () => {
+	test('create', () => {
+		const dispatcher = new CommandDispatcher()
+	})
+
+	test('execute', async () => {
+		const dispatcher = new CommandDispatcher()
+		dispatcher.register(literal('foo')
+			.executes(async () => 2)
+		)
+		const result = await dispatcher.execute('foo', undefined)
+		expect(result).toEqual(2)
+	})
+
+	test('execute (zero result)', async () => {
+		const dispatcher = new CommandDispatcher()
+		dispatcher.register(literal('foo')
+			.executes(async () => 0)
+		)
+		const result = await dispatcher.execute('foo', undefined)
+		expect(result).toEqual(0)
+	})
+})

package/test/StringReader.test.ts

@@ -0,0 +1,47 @@
+import { StringReader } from '../src/StringReader'
+
+describe('StringReader', () => {
+	test('readInt', () => {
+		const reader = new StringReader('5')
+		const value = reader.readInt()
+		expect(value).toEqual(5)
+	})
+
+	test('readInt (trailing)', () => {
+		const reader = new StringReader('5a')
+		const value = reader.readInt()
+		expect(value).toEqual(5)
+		expect(reader.getCursor()).toEqual(1)
+	})
+
+	test('readInt (NaN)', () => {
+		const reader = new StringReader('5-')
+		expect(() => reader.readInt()).toThrow('Invalid integer')
+	})
+
+	test('readInt (invalid)', () => {
+		const reader = new StringReader('a')
+		expect(() => reader.readInt()).toThrow('Expected integer')
+	})
+
+	test('readInt (float)', () => {
+		const reader = new StringReader('1.3')
+		expect(() => reader.readInt()).toThrow('Invalid integer')
+	})
+
+	test('readFloat', () => {
+		const reader = new StringReader('1.3')
+		const value = reader.readFloat()
+		expect(value).toEqual(1.3)
+	})
+
+	test('readFloat (NaN)', () => {
+		const reader = new StringReader('1.3-')
+		expect(() => reader.readFloat()).toThrow('Invalid float')
+	})
+
+	test('readFloat (invalid)', () => {
+		const reader = new StringReader('sw')
+		expect(() => reader.readFloat()).toThrow('Expected float')
+	})
+})

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "es5",
+        "module": "commonjs",
+        "lib": [ "es2015", "dom" ],
+        "declaration": true,
+        "outDir": "dist"
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}