@jsprismarine/brigadier 0.1.0 → 0.2.1

package/src/lib/StringReader.ts

@@ -1,210 +0,0 @@
-import ImmutableStringReader from "./ImmutableStringReader"
-import CommandSyntaxException from "./exceptions/CommandSyntaxException"
-
-const SYNTAX_ESCAPE = '\\';
-const SYNTAX_QUOTE = '\"';
-
-export default class StringReader implements ImmutableStringReader {        
-	
-	private string: string;
-    private cursor: number = 0;
-    
-    public constructor (other: string | StringReader) {
-		if(typeof other === "string") {
-			this.string = other;        	
-		} else {
-			this.string = other.string;
-			this.cursor = other.cursor;
-		}			
-    }
-    
-    public getString(): string {
-        return this.string;
-    }
-    
-    public setCursor(cursor: number) {
-        this.cursor = cursor;
-    }
-    
-    public getRemainingLength(): number {
-        return (this.string.length - this.cursor);
-    }
-    
-    public getTotalLength(): number {
-        return this.string.length;
-    }
-    
-
-    public getCursor(): number {
-        return this.cursor;
-    }
-    
-
-    public getRead(): string {
-        return this.string.substring(0, this.cursor);
-    }
-    
-
-    public getRemaining(): string {
-        return this.string.substring(this.cursor);
-    }
-    
-    public canRead(length = 1): boolean {
-        return this.cursor + length <= this.string.length;
-    }    
-
-    public peek(offset: number = 0): string {
-        return this.string.charAt(this.cursor + offset);
-    }
-    
-    public read(): string {
-        return this.string.charAt(this.cursor++);
-    }
-    
-    public skip() {
-        this.cursor++;
-    }
-    
-    public static isAllowedNumber(c: string): boolean {
-        return c >= '0' && c <= '9' || c == '.' || c == '-' || c == '+' || c == 'e' || c == 'E';
-    }
-    
-    public skipWhitespace() {
-        while ((this.canRead() && /\s/.test(this.peek()))) {
-            this.skip();
-        }
-        
-    }
-    
-    public readInt(): number {
-        let start = this.cursor;
-        while (this.canRead() && StringReader.isAllowedNumber(this.peek())) {
-            this.skip();
-        }
-        
-		let number = this.string.substring(start, this.cursor);
-        if (number.length === 0) {
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedInt().createWithContext(this);
-        }
-        
-		const result = parseFloat(number);		
-		if (isNaN(result) || result !== Math.round(result)) {
-			this.cursor = start;
-			throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidInt().createWithContext(this, number);
-		} else 
-			return result;
-    }
-    
-    public readFloat(): number {
-        let start = this.cursor;
-        while ((this.canRead() && StringReader.isAllowedNumber(this.peek()))) {
-            this.skip();
-        }
-        
-		let number = this.string.substring(start, this.cursor);
-        if (number.length === 0) {
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedFloat().createWithContext(this);
-        }
-        
-		const result = parseFloat(number);
-		if (isNaN(result) || result !== Number(number)) {
-			this.cursor = start;
-			throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidFloat().createWithContext(this, number);
-		} else 
-			return result;                
-    }
-    
-    public static isAllowedInUnquotedString(c: string): boolean {
-		return c >= '0' && c <= '9'
-		|| c >= 'A' && c <= 'Z'
-		|| c >= 'a' && c <= 'z'
-		|| c == '_' || c == '-'
-		|| c == '.' || c == '+';
-    }
-    
-    public readUnquotedString(): string {
-        let start = this.cursor;
-        while (this.canRead() && StringReader.isAllowedInUnquotedString(this.peek())) {
-            this.skip();
-        }
-        
-        return this.string.substring(start, this.cursor);
-    }
-    
-    public readQuotedString(): string {
-        if (!this.canRead()) {
-            return "";
-        }
-        else if ((this.peek() != SYNTAX_QUOTE)) {
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedStartOfQuote().createWithContext(this);
-        }
-        
-        this.skip();
-        let result = "";
-        let escaped = false;
-        while (this.canRead()) {
-            let c = this.read();
-            if (escaped) {
-                if (c == SYNTAX_QUOTE || c == SYNTAX_ESCAPE) {
-                    result += c;
-                    escaped = false;
-                }
-                else {
-                    this.setCursor(this.getCursor() - 1);
-                    throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidEscape().createWithContext(this, c);
-                }
-                
-            }
-            else if (c == SYNTAX_ESCAPE) {
-                escaped = true;
-            }
-            else if (c == SYNTAX_QUOTE) {
-                return result;
-            }
-            else {
-                result += c;
-            }
-            
-        }
-        
-        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedEndOfQuote().createWithContext(this);
-    }
-    
-    public readString(): string {
-        if (this.canRead() && (this.peek() === SYNTAX_QUOTE)) {
-            return this.readQuotedString();
-        }
-        else {
-            return this.readUnquotedString();
-        }
-        
-    }
-    
-    public readBoolean(): boolean {
-        let start = this.cursor;
-        let value = this.readString();
-        if (value.length === 0) {
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedBool().createWithContext(this);
-        }
-        
-        if (value === "true") {
-            return true;
-        }
-        else if (value === "false") {
-            return false;
-        }
-        else {
-            this.cursor = start;
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerInvalidBool().createWithContext(this, value);
-        }
-        
-    }
-    
-    public expect(c: string) {
-        if (!this.canRead() || this.peek() !== c) {
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedSymbol().createWithContext(this, c);
-        }
-        
-        this.skip();
-    }
-}

package/src/lib/arguments/ArgumentType.ts

@@ -1,27 +0,0 @@
-import StringReader from "../StringReader"
-import CommandContext from "../context/CommandContext"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-
-import BoolArgumentType from "./BoolArgumentType"
-import IntegerArgumentType from "./IntegerArgumentType"
-import FloatArgumentType from "./FloatArgumentType"
-import StringArgumentType from "./StringArgumentType"
-
-export const DefaultType = {
-	bool: BoolArgumentType.bool,
-	integer: IntegerArgumentType.integer,
-	float: FloatArgumentType.float,
-	word: StringArgumentType.word,
-	string: StringArgumentType.string,
-	greedyString: StringArgumentType.greedyString
-}
-
-export default interface ArgumentType<T> {
-    
-    parse(reader: StringReader): T;
-    
-    listSuggestions?<S>(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    
-    getExamples?(): Iterable<string>;
-}

package/src/lib/arguments/BoolArgumentType.ts

@@ -1,41 +0,0 @@
-import StringReader from "../StringReader"
-import CommandContext from "../context/CommandContext"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-import ArgumentType from "./ArgumentType"
-
-const EXAMPLES = ["true", "false"];
-
-export default class BoolArgumentType implements ArgumentType<boolean> {
-
-    private constructor () {
-    }
-
-    public static bool(): BoolArgumentType {
-        return new BoolArgumentType();
-    }
-
-    public static getBool(context: CommandContext<any>, name: string): boolean {
-        return context.getArgument(name, Boolean);
-    }
-
-    public parse(reader: StringReader): boolean {
-        return reader.readBoolean();
-    }
-
-    public listSuggestions(context: CommandContext<any>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        if ("true".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("true");
-        }
-
-        if ("false".startsWith(builder.getRemaining().toLowerCase())) {
-            builder.suggest("false");
-        }
-
-        return builder.buildPromise();
-    }
-
-    public getExamples(): Iterable<string> {
-        return EXAMPLES;
-    }
-}

package/src/lib/arguments/FloatArgumentType.ts

@@ -1,75 +0,0 @@
-import StringReader from "../StringReader"
-import CommandContext from "../context/CommandContext"
-import CommandSyntaxException from "../exceptions/CommandSyntaxException"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-import ArgumentType from "./ArgumentType"
-
-const EXAMPLES = ["0", "1.2", ".5", "-1", "-.5", "-1234.56"];
-
-export default class FloatArgumentType implements ArgumentType<number> {    
-    
-    private minimum: number;    
-    private maximum: number;
-    
-    private constructor (minimum: number, maximum: number) {
-        this.minimum = minimum;
-        this.maximum = maximum;
-    }
-    
-    public static float(min: number = -Infinity, max: number = Infinity): FloatArgumentType {
-        return new FloatArgumentType(min, max);
-    }
-    
-    public static getFloat(context: CommandContext<any>, name: string): number {
-        return context.getArgument(name, Number);
-    }
-    
-    public getMinimum(): number {
-        return this.minimum;
-    }
-    
-    public getMaximum(): number {
-        return this.maximum;
-    }
-    
-    public parse(reader: StringReader): number {
-        let start = reader.getCursor();
-        let result = reader.readFloat();
-        if (result < this.minimum) {
-            reader.setCursor(start);
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooLow().createWithContext(reader, result, this.minimum);
-        }
-        
-        if (result > this.maximum) {
-            reader.setCursor(start);
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooHigh().createWithContext(reader, result, this.maximum);
-        }
-        
-        return result;
-    }
-        
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        
-        if (!(o instanceof FloatArgumentType)) return false;
-        
-        return this.maximum == o.maximum && this.minimum == o.minimum;
-    }
-
-    public toString(): string {		
-        if (this.minimum === -Infinity && this.maximum === Infinity) {
-            return "float()";
-        }
-        else if (this.maximum == Infinity) {			
-            return "float(" + this.minimum + ")";
-        }
-        else {
-            return "float(" + this.minimum + ", " + this.maximum + ")";
-        }        
-	}
-	
-    public getExamples(): Iterable<string> {
-        return EXAMPLES;
-    }
-}

package/src/lib/arguments/IntegerArgumentType.ts

@@ -1,75 +0,0 @@
-import StringReader from "../StringReader"
-import CommandContext from "../context/CommandContext"
-import CommandSyntaxException from "../exceptions/CommandSyntaxException"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-import ArgumentType from "./ArgumentType"
-
-const EXAMPLES = ["0", "123", "-123"];
-
-export default class IntegerArgumentType implements ArgumentType<number> {    
-    
-    private minimum: number;    
-    private maximum: number;
-    
-    private constructor (minimum: number, maximum: number) {
-        this.minimum = minimum;
-        this.maximum = maximum;
-    }
-    
-    public static integer(min: number = -Infinity, max: number = Infinity): IntegerArgumentType {
-        return new IntegerArgumentType(min, max);
-    }
-    
-    public static getInteger(context: CommandContext<any>, name: string): number {
-        return context.getArgument(name, Number);
-    }
-    
-    public getMinimum(): number {
-        return this.minimum;
-    }
-    
-    public getMaximum(): number {
-        return this.maximum;
-    }
-    
-    public parse(reader: StringReader): number {
-        let start = reader.getCursor();
-        let result = reader.readInt();
-        if (result < this.minimum) {
-            reader.setCursor(start);
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooLow().createWithContext(reader, result, this.minimum);
-        }
-        
-        if (result > this.maximum) {
-            reader.setCursor(start);
-            throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.integerTooHigh().createWithContext(reader, result, this.maximum);
-        }
-        
-        return result;
-    }
-        
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        
-        if (!(o instanceof  IntegerArgumentType)) return false;
-        
-        return this.maximum == o.maximum && this.minimum == o.minimum;
-    }
-    
-    public toString(): string {
-        if (this.minimum === -Infinity && this.maximum === Infinity) {
-            return "integer()";
-        }
-        else if (this.maximum == Infinity) {
-            return "integer(" + this.minimum + ")";
-        }
-        else {
-            return "integer(" + this.minimum + ", " + this.maximum + ")";
-        }        
-    }
-    
-    public getExamples(): Iterable<string> {
-        return EXAMPLES;
-    }
-}

package/src/lib/arguments/StringArgumentType.ts

@@ -1,83 +0,0 @@
-import StringReader from "../StringReader"
-import CommandContext from "../context/CommandContext"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-import ArgumentType from "./ArgumentType"
-
-export enum StringType {
-	SINGLE_WORD = "words_with_underscores",
-	QUOTABLE_PHRASE = "\"quoted phrase\"",
-	GREEDY_PHRASE = "words with spaces"
-}
-
-export default class StringArgumentType implements ArgumentType<string> {
-    
-    private type: StringType;
-    
-    private constructor (type: StringType) {
-        this.type = type;
-    }
-    
-	public static word(): StringArgumentType {
-        return new StringArgumentType(StringType.SINGLE_WORD);
-    }
-
-    public static string(): StringArgumentType {
-        return new StringArgumentType(StringType.QUOTABLE_PHRASE);
-    }
-
-    public static greedyString(): StringArgumentType {
-        return new StringArgumentType(StringType.GREEDY_PHRASE);
-    }
-    
-    public static getString(context: CommandContext<any>, name: string): string {
-        return context.getArgument(name, String);
-    }
-    
-    public getType(): StringType {
-        return this.type;
-    }
-
-    public parse(reader: StringReader): string {
-        if (this.type == StringType.GREEDY_PHRASE) {
-            let text = reader.getRemaining();
-            reader.setCursor(reader.getTotalLength());
-            return text;
-        }
-        else if (this.type == StringType.SINGLE_WORD) {
-            return reader.readUnquotedString();
-        }
-        else {
-            return reader.readString();
-        }
-        
-    }
-
-    public toString(): string {
-        return "string()";
-	}	
-    
-    public static escapeIfRequired(input: string): String {
-        for (let c of input) {
-            if (!StringReader.isAllowedInUnquotedString(c)) {
-                return StringArgumentType.escape(input);
-            }            
-        }
-        
-        return input;
-    }
-    
-    private static escape(input: string): string {
-		let result = "\"";
-		for (let i = 0; i < input.length; i++) {
-            const c = input.charAt(i);
-            if (c == '\\' || c == '"') {
-                result += '\\';
-            }
-            result += c;
-        }
-
-        result += "\"";
-        return result;
-    }
-}

package/src/lib/builder/ArgumentBuilder.ts

@@ -1,94 +0,0 @@
-import Command from "../Command"
-import RedirectModifier from "../RedirectModifier"
-import SingleRedirectModifier from "../SingleRedirectModifier"
-import CommandNode from "../tree/CommandNode"
-import RootCommandNode from "../tree/RootCommandNode"
-import Predicate from "../Predicate"
-import CommandContext from "../context/CommandContext";
-
-abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
-    
-    private args: RootCommandNode<S> = new RootCommandNode();
-    
-    private command: Command<S>;
-    
-    private requirement: Predicate<S>;
-    
-    private target: CommandNode<S>;
-    
-    private modifier: RedirectModifier<S> = null;
-    
-    private forks: boolean;
-    
-    public abstract getThis(): T;
-    
-    public then(arg: ArgumentBuilder<S, any> | CommandNode<S>): T {
-        if (!(this.target == null)) {
-            throw new Error("Cannot add children to a redirected node");
-        }
-		
-		if (arg instanceof CommandNode)
-			this.args.addChild(arg)
-		else
-			this.args.addChild(arg.build());
-			
-        return this.getThis();
-    }
-    
-    public getArguments(): Iterable<CommandNode<S>> {
-        return this.args.getChildren();
-    }
-    
-    public executes(command: Command<S>): T {
-        this.command = command;
-        return this.getThis();
-    }
-    
-    public getCommand(): Command<S> {
-        return this.command;
-    }
-    
-    public requires(requirement: Predicate<S>): T {
-        this.requirement = requirement;
-        return this.getThis();
-    }
-    
-    public getRequirement(): Predicate<S> {
-        return this.requirement;
-    }
-    
-    public redirect(target: CommandNode<S>, modifier?: SingleRedirectModifier<S>): T {
-        return this.forward(target, modifier == null ? null : (o: CommandContext<S>) => [ modifier.apply(o) ], false);
-    }
-    
-    public fork(target: CommandNode<S>, modifier: RedirectModifier<S>): T {
-        return this.forward(target, modifier, true);
-    }
-    
-    public forward(target: CommandNode<S>, modifier: RedirectModifier<S>, fork: boolean): T {
-        if (this.args.getChildrenCount() > 0) {
-            throw new Error("Cannot forward a node with children");
-        }
-        
-        this.target = target;
-        this.modifier = modifier;
-        this.forks = fork;
-        return this.getThis();
-    }
-    
-    public getRedirect(): CommandNode<S> {
-        return this.target;
-    }
-    
-    public getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
-    
-    public isFork(): boolean {
-        return this.forks;
-    }
-    
-    public abstract build(): CommandNode<S>;
-}
-
-export default ArgumentBuilder;

package/src/lib/builder/LiteralArgumentBuilder.ts

@@ -1,35 +0,0 @@
-import LiteralCommandNode from "../tree/LiteralCommandNode"
-import ArgumentBuilder from "./ArgumentBuilder"
-
-export default class LiteralArgumentBuilder<S> extends ArgumentBuilder<S, LiteralArgumentBuilder<S>> {
-    
-    private literal: string;
-    
-    public constructor (literal: string) {
-		super();
-        this.literal = literal;
-    }
-    
-    public static literal<S>(name: string): LiteralArgumentBuilder<S> {
-        return new LiteralArgumentBuilder(name);
-    }
-
-    public getThis(): LiteralArgumentBuilder<S> {
-        return this;
-    }
-    
-    public getLiteral(): string {
-        return this.literal;
-    }
-
-    public build(): LiteralCommandNode<S> {
-        let result: LiteralCommandNode<S> = new LiteralCommandNode(this.getLiteral(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork());
-        for (let arg of this.getArguments()) {
-            result.addChild(arg);
-        }
-        
-        return result;
-    }
-}
-
-export const literal = LiteralArgumentBuilder.literal;

package/src/lib/builder/RequiredArgumentBuilder.ts

@@ -1,54 +0,0 @@
-import ArgumentType from "../arguments/ArgumentType"
-import SuggestionProvider from "../suggestion/SuggestionProvider"
-import ArgumentCommandNode from "../tree/ArgumentCommandNode"
-import ArgumentBuilder from "./ArgumentBuilder"
-
-export default class RequiredArgumentBuilder<S, T> extends ArgumentBuilder<S, RequiredArgumentBuilder<S, T>> {
-    
-    private name: string;
-    
-    private type: ArgumentType<T>;
-    
-    private suggestionsProvider: SuggestionProvider<S>;
-    
-    private constructor (name: string, type: ArgumentType<T>) {
-		super();
-        this.name = name;
-        this.type = type;
-    }
-    
-    public static argument<S, T>(name: string, type: ArgumentType<T>): RequiredArgumentBuilder<S, T> {
-        return new RequiredArgumentBuilder(name, type);
-    }
-    
-    public suggests(provider: SuggestionProvider<S>): RequiredArgumentBuilder<S, T> {
-        this.suggestionsProvider = provider;
-        return this.getThis();
-    }
-    
-    public getSuggestionsProvider(): SuggestionProvider<S> {
-        return this.suggestionsProvider;
-    }
-
-    public getThis(): RequiredArgumentBuilder<S, T> {
-        return this;
-    }
-    
-    public getType(): ArgumentType<T> {
-        return this.type;
-    }
-    
-    public getName(): string {
-        return this.name;
-    }
-    
-    public build(): ArgumentCommandNode<S, T> {
-        let result: ArgumentCommandNode<S, T> = new ArgumentCommandNode(this.getName(), this.getType(), this.getCommand(), this.getRequirement(), this.getRedirect(), this.getRedirectModifier(), this.isFork(), this.getSuggestionsProvider());
-        for (let arg of this.getArguments()) {
-            result.addChild(arg);
-        }        
-        return result;
-    }
-}
-
-export const argument = RequiredArgumentBuilder.argument;