@jsprismarine/brigadier 0.1.0 → 0.2.1

package/src/lib/exceptions/SimpleCommandExceptionType.ts

@@ -1,26 +0,0 @@
-import Message from "../Message"
-import ImmutableStringReader from "../ImmutableStringReader"
-import CommandExceptionType from "./CommandExceptionType"
-import CommandSyntaxException from "./CommandSyntaxException";
-
-export default class SimpleCommandExceptionType implements CommandExceptionType {
-    
-    private message: Message;
-    
-    public constructor (message: Message) {
-		this.message = message;
-		Error.captureStackTrace(this, SimpleCommandExceptionType)
-    }
-    
-    public create(): CommandSyntaxException {
-        return new CommandSyntaxException(this, this.message)
-    }
-    
-    public createWithContext(reader: ImmutableStringReader): CommandSyntaxException {
-        return new CommandSyntaxException(this, this.message, reader.getString(), reader.getCursor());
-    }
-    
-    public toString(): string {
-        return this.message.getString();
-    }
-}

package/src/lib/suggestion/IntegerSuggestion.ts

@@ -1,46 +0,0 @@
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-
-export default class IntegerSuggestion extends Suggestion {
-    
-    private value: number;
-    
-    public constructor (range: StringRange, value: number, tooltip: Message = null) {
-        super(range, value.toString(), tooltip);
-        this.value = value;
-    }
-    
-    public getValue(): number {
-        return this.value;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        
-        if (!(o instanceof IntegerSuggestion)) return false;
-        
-        return this.value == o.value && super.equals(o);
-    }
-    
-    public toString(): String {
-        return "IntegerSuggestion{" +
-                "value=" + this.value +
-                ", range=" + this.getRange() +
-                ", text='" + this.getText() + '\'' +
-                ", tooltip='" + this.getTooltip() + '\'' +
-                '}';
-    }
-
-    public compareTo(o: Suggestion): number {
-        if (o instanceof IntegerSuggestion) {
-            return this.value < o.value ? 1 : - 1;
-        }
-        
-        return super.compareTo(o);
-    }
-
-    public compareToIgnoreCase(b: Suggestion): number {
-        return this.compareTo(b);
-    }
-}

package/src/lib/suggestion/Suggestion.ts

@@ -1,87 +0,0 @@
-import isEqual from "../util/isEqual"
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-
-export default class Suggestion {
-    
-    private range: StringRange;    
-    private text: string;    
-    private tooltip: Message;
-    
-    public constructor (range: StringRange, text: string, tooltip: Message = null) {
-        this.range = range;
-        this.text = text;
-        this.tooltip = tooltip;
-    }
-    
-    public getRange(): StringRange {
-        return this.range;
-    }
-    
-    public getText(): string {
-        return this.text;
-    }
-    
-    public getTooltip(): Message {
-        return this.tooltip;
-    }
-    
-    public 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;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;        
-        if (!(o instanceof  Suggestion)) return false;
-        
-        return isEqual(this.range, o.range) && (this.text === o.text) && isEqual(this.tooltip, o.tooltip);
-    }
-    
-    public toString(): String {
-        return "Suggestion{" +
-		"range=" + this.range +
-		", text='" + this.text + '\'' +
-		", tooltip='" + this.tooltip + '\'' +
-		'}';
-    }
-    
-    public compareTo(o: Suggestion): number {
-        return this.text < o.text ? 1 : -1;
-    }
-    
-    public compareToIgnoreCase(b: Suggestion): number {
-        return this.text.toLowerCase() < b.text.toLowerCase() ? 1 : -1;
-    }
-    
-    public expand(command: string, range: StringRange): Suggestion {
-        if (range.equals(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/lib/suggestion/SuggestionProvider.ts

@@ -1,7 +0,0 @@
-import Suggestions from "./Suggestions"
-import SuggestionsBuilder from "./SuggestionsBuilder"
-import CommandContext from "../context/CommandContext"
-
-export default interface SuggestionProvider<S> {    
-    getSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-}

package/src/lib/suggestion/Suggestions.ts

@@ -1,85 +0,0 @@
-import isEqual from "../util/isEqual"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-
-export default class Suggestions {
-
-    private static EMPTY = new Suggestions(StringRange.at(0), []);
-
-    private range: StringRange;
-
-    private suggestions: Array<Suggestion>;
-
-    public constructor (range: StringRange, suggestions: Array<Suggestion>) {
-        this.range = range;
-        this.suggestions = suggestions;
-    }
-
-    public getRange(): StringRange {
-        return this.range;
-    }
-
-    public getList(): Array<Suggestion> {
-        return this.suggestions;
-    }
-
-    public isEmpty(): boolean {
-        return this.suggestions.length === 0;
-    }
-
-    public equals(o: object): boolean {
-        if (this === o) return true;
-
-        if (!(o instanceof  Suggestions)) return false;
-
-        return this.range.equals(o.range) && isEqual(this.suggestions, o.suggestions);
-    }
-
-    public toString(): String {
-		return "Suggestions{" +
-		"range=" + this.range +
-		", suggestions=" + this.suggestions + '}';
-    }
-
-    public static empty(): Promise<Suggestions> {
-        return Promise.resolve(this.EMPTY);
-    }
-
-    public static merge(command: string, input: Array<Suggestions>): Suggestions {
-        if (input.length === 0) {
-            return this.EMPTY;
-        }
-        else if (input.length === 1) {
-            return input[0];
-        }
-
-        const texts = [];
-        for (let suggestions of input) {
-            texts.push(...suggestions.getList());
-        }
-
-        return Suggestions.create(command, texts);
-    }
-
-    public static create(command: string, suggestions: Array<Suggestion>): Suggestions {
-        if (suggestions.length === 0) {
-            return this.EMPTY;
-        }
-
-        let start = Infinity;
-        let end = -Infinity;
-        for (let suggestion of suggestions) {
-            start = Math.min(suggestion.getRange().getStart(), start);
-            end = Math.max(suggestion.getRange().getEnd(), end);
-        }
-
-        let range = new StringRange(start, end);
-        const texts = [];
-        for (let suggestion of suggestions) {
-            texts.push(suggestion.expand(command, range));
-        }
-
-        const sorted = texts.sort((a, b) => a.compareToIgnoreCase(b));
-        return new Suggestions(range, sorted);
-    }
-}

package/src/lib/suggestion/SuggestionsBuilder.ts

@@ -1,69 +0,0 @@
-import Message from "../Message"
-import StringRange from "../context/StringRange"
-import Suggestion from "./Suggestion"
-import Suggestions from "./Suggestions"
-import IntegerSuggestion from "./IntegerSuggestion"
-
-export default class SuggestionsBuilder {
-    
-    private input: string;
-    
-    private start: number;
-    
-    private remaining: string;
-    
-    private result: Array<Suggestion> = [];
-    
-    public constructor (input: string, start: number) {
-        this.input = input;
-        this.start = start;
-        this.remaining = input.substring(start);
-    }
-    
-    public getInput(): String {
-        return this.input;
-    }
-    
-    public getStart(): number {
-        return this.start;
-    }
-    
-    public getRemaining(): string {
-        return this.remaining;
-    }
-    
-    public build(): Suggestions {
-        return Suggestions.create(this.input, this.result);
-    }
-    
-    public buildPromise(): Promise<Suggestions> {
-        return Promise.resolve(this.build());
-    }
-    
-    public suggest(text: string | number, tooltip: Message = null): SuggestionsBuilder {
-
-		if(typeof text === "number") {
-			this.result.push(new IntegerSuggestion(StringRange.between(this.start, this.input.length), text, tooltip));
-			return this;
-		}
-
-        if (text === this.remaining)
-            return this;
-        
-        this.result.push(new Suggestion(StringRange.between(this.start, this.input.length), text, tooltip));
-        return this;
-    }        
-    
-    public add(other: SuggestionsBuilder): SuggestionsBuilder {
-        this.result.push(...other.result);
-        return this;
-    }
-    
-    public createOffset(start: number): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, this.start);
-    }
-    
-    public restart(): SuggestionsBuilder {
-        return new SuggestionsBuilder(this.input, this.start);
-    }
-}

package/src/lib/tree/ArgumentCommandNode.ts

@@ -1,118 +0,0 @@
-import isEqual from "../util/isEqual"
-import Command from "../Command"
-import Predicate from "../Predicate"
-import RedirectModifier from "../RedirectModifier"
-import StringReader from "../StringReader"
-import ArgumentType from "../arguments/ArgumentType"
-import RequiredArgumentBuilder from "../builder/RequiredArgumentBuilder"
-import CommandContext from "../context/CommandContext"
-import ParsedArgument from "../context/ParsedArgument"
-import CommandContextBuilder from "../context/CommandContextBuilder"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionProvider from "../suggestion/SuggestionProvider"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-import CommandNode from "./CommandNode"
-
-const USAGE_ARGUMENT_OPEN: string = "<";    
-const USAGE_ARGUMENT_CLOSE: string = ">";
-
-export default class ArgumentCommandNode<S, T> extends CommandNode<S> {        
-    
-    private name: string;    
-    private type: ArgumentType<T>;    
-    private customSuggestions: SuggestionProvider<S>;
-    
-    public constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean, customSuggestions: SuggestionProvider<S>) {
-        super(command, requirement, redirect, modifier, forks);
-        this.name = name;
-        this.type = type;
-        this.customSuggestions = customSuggestions;
-	}
-	
-	public getNodeType(): string {
-		return "argument"
-	}
-    
-    public getType(): ArgumentType<T> {
-        return this.type;
-    }
-    
-    public getName(): string {
-        return this.name;
-    }
-    
-    public getUsageText(): string {
-        return USAGE_ARGUMENT_OPEN + this.name + USAGE_ARGUMENT_CLOSE;
-    }
-    
-    public getCustomSuggestions(): SuggestionProvider<S> {
-        return this.customSuggestions;
-    }
-    
-    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {
-        let start = reader.getCursor();
-        let result: T = this.type.parse(reader);
-        let parsed: ParsedArgument<S, T> = new ParsedArgument(start, reader.getCursor(), result);
-        contextBuilder.withArgument(this.name, parsed);
-        contextBuilder.withNode(this, parsed.getRange());
-    }
-    
-    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        if (this.customSuggestions == null) {
-            if (typeof this.type.listSuggestions === "function")
-                return this.type.listSuggestions(context, builder);
-            else 
-                return Suggestions.empty();
-        }
-        else {
-            return this.customSuggestions.getSuggestions(context, builder);
-        }
-        
-    }
-    
-    public createBuilder(): RequiredArgumentBuilder<S, T> {
-        let builder: RequiredArgumentBuilder<S, T> = RequiredArgumentBuilder.argument(this.name, this.type);
-        builder.requires(this.getRequirement());
-        builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
-        builder.suggests(this.customSuggestions);
-        if (this.getCommand() != null) {
-            builder.executes(this.getCommand());
-        }
-        
-        return builder;
-    }
-    
-    public isValidInput(input: string): boolean {
-        try {
-            let reader: StringReader = new StringReader(input);
-            this.type.parse(reader);
-            return !reader.canRead() || reader.peek() == ' ';
-        }
-        catch (ignored) {
-        }
-        
-        return false;
-    }
-    
-    public equals(o: object): boolean {
-        if (this === o) return true;        
-        if (!(o instanceof  ArgumentCommandNode)) return false;
-        
-        if (!(this.name === o.name)) return false;
-        if (!isEqual(this.type, o.type)) return false;
-        
-        return super.equals(o);
-    }
-    
-    public getSortedKey(): string {
-        return this.name;
-    }
-    
-    public getExamples(): Iterable<string> {
-        return typeof this.type.getExamples === "function" ? this.type.getExamples() : [];
-    }
-    
-    public toString(): string {
-        return "<argument " + this.name + ":" + this.type + ">";
-    }
-}

package/src/lib/tree/CommandNode.ts

@@ -1,200 +0,0 @@
-import isEqual from "../util/isEqual"
-import Predicate from "../Predicate"
-import AmbiguityConsumer from "../AmbiguityConsumer"
-import Command from "../Command"
-import RedirectModifier from "../RedirectModifier"
-import StringReader from "../StringReader"
-import ArgumentBuilder from "../builder/ArgumentBuilder"
-import CommandContext from "../context/CommandContext"
-import CommandContextBuilder from "../context/CommandContextBuilder"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-
-abstract class CommandNode<S> {
-    
-    private children: Map<string, CommandNode<S>> = new Map();
-    
-    private literals: Map<string, any> = new Map();
-    
-    private args: Map<string, any> = new Map();
-    
-    private requirement: Predicate<S>;
-    
-    private redirect: CommandNode<S>;
-    
-    private modifier: RedirectModifier<S>;
-    
-    private forks: boolean;
-    
-	private command: Command<S>;
-	
-	public abstract getNodeType(): string;
-    
-    public constructor (command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean) {
-        this.command = command;
-        this.requirement = requirement || (() => true);
-        this.redirect = redirect;
-        this.modifier = modifier;
-        this.forks = forks;
-    }
-    
-    public getCommand(): Command<S> {
-        return this.command;
-    }
-    
-    public getChildren(): IterableIterator<CommandNode<S>> {
-        return this.children.values();
-	}
-	
-	public getChildrenCount(): number {
-		return this.children.size;
-	}
-    
-    public getChild(name: string): CommandNode<S> {
-        return this.children.get(name);
-    }
-    
-    public getRedirect(): CommandNode<S> {
-        return this.redirect;
-    }
-    
-    public getRedirectModifier(): RedirectModifier<S> {
-        return this.modifier;
-    }
-    
-    public canUse(source: S): boolean {
-        return this.requirement(source);
-    }
-    
-    public addChild(node: CommandNode<S>) {
-        if (node.getNodeType() === "root") {
-            throw new Error("Cannot add a RootCommandNode as a child to any other CommandNode");
-        }
-        
-        let child= this.children.get(node.getName());
-        if (child != null) {
-            //  We've found something to merge onto
-            if ((node.getCommand() != null)) {
-                child.command = node.getCommand();
-            }
-            
-            for (let grandchild of node.getChildren()) {
-                child.addChild(grandchild);
-            }
-            
-        }
-        else {
-            this.children.set(node.getName(), node);
-            if (node.getNodeType() === "literal") {
-                this.literals.set(node.getName(), node);
-            }
-            else if (node.getNodeType() === "argument") {
-                this.args.set(node.getName(), node);
-            }
-            
-        }
-        
-		this.children = new Map([...this.children.entries()].sort((a, b) => a[1].compareTo(b[1])))
-    }
-    
-    public findAmbiguities(consumer: AmbiguityConsumer<S>) {
-        let matches: Array<string> = [];
-        for (let child of this.children.values()) {
-            for (let sibling of this.children.values()) {
-                if (child === sibling) {
-                    continue;
-                }
-                
-                for (let input of child.getExamples()) {
-                    if (sibling.isValidInput(input)) {
-                        matches.push(input);
-                    }                    
-                }
-                
-                if (matches.length > 0) {
-                    consumer.ambiguous(this, child, sibling, matches);
-                    matches = [];
-                }
-                
-            }
-            
-            child.findAmbiguities(consumer);
-        }
-        
-    }
-    
-    public abstract isValidInput(input: string): boolean;
-    
-    public equals(o: object): boolean {
-        if (this === o) return true;
-        if (!(o instanceof CommandNode)) return false;
-
-		if (this.children.size !== o.children.size) {
-			return false;
-		}
-		
-		if (!isEqual(this.children, o.children)) return false;
-
-		if (this.command != null ? !isEqual(this.command, o.command) : o.command != null) 
-			return false;
-
-        return true;
-    }
-    
-    public getRequirement() {
-        return this.requirement;
-    }
-    
-    public abstract getName(): string;
-    
-    public abstract getUsageText(): string;
-    
-    public abstract parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
-    
-    public abstract listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions>;
-    
-    public abstract createBuilder(): ArgumentBuilder<S, any>;
-    
-    public abstract getSortedKey(): string;
-    
-    public getRelevantNodes(input: StringReader): Iterable<CommandNode<S>> {
-        if (this.literals.size > 0) {
-            let cursor: number = input.getCursor();
-            while ((input.canRead() 
-                        && (input.peek() != ' '))) {
-                input.skip();
-            }
-            
-            let text = input.getString().substring(cursor, input.getCursor());
-            input.setCursor(cursor);
-            let literal = this.literals.get(text);
-            if (literal != null) {
-				return[ literal ];
-            }
-            else {
-                return this.args.values();
-            }
-            
-        }
-        else {
-            return this.args.values();
-        }
-        
-    }
-    
-    public compareTo(o: CommandNode<S>): number {
-		if (this.getNodeType() === o.getNodeType()) {
-            return this.getSortedKey() > o.getSortedKey() ? 1 : -1;
-        }
-
-        return (o.getNodeType() === "literal") ? 1 : -1;
-    }
-    
-    public isFork(): boolean {
-        return this.forks;
-    }
-    
-    public abstract getExamples(): Iterable<string>;
-}
-
-export default CommandNode;