@jsprismarine/brigadier 0.1.0 → 0.2.1

package/src/lib/tree/LiteralCommandNode.ts

@@ -1,111 +0,0 @@
-import Command from "../Command"
-import CommandNode from "./CommandNode"
-import Predicate from "../Predicate"
-import RedirectModifier from "../RedirectModifier"
-import StringReader from "../StringReader"
-import LiteralArgumentBuilder from "../builder/LiteralArgumentBuilder"
-import CommandContext from "../context/CommandContext"
-import CommandContextBuilder from "../context/CommandContextBuilder"
-import StringRange from "../context/StringRange"
-import CommandSyntaxException from "../exceptions/CommandSyntaxException"
-import Suggestions from "../suggestion/Suggestions"
-import SuggestionsBuilder from "../suggestion/SuggestionsBuilder"
-
-export default class LiteralCommandNode<S> extends CommandNode<S> {
-    
-    private literal: string;
-    
-    public 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;
-	}
-
-	public getNodeType(): string {
-		return "literal"
-	}
-    
-    public getLiteral(): string {
-        return this.literal;
-    }
-    
-    public getName(): string {
-        return this.literal;
-    }
-    
-    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {
-        let start = reader.getCursor();
-        let end = this.__parse(reader);
-        if (end > -1) {
-            contextBuilder.withNode(this, StringRange.between(start, end));
-            return;
-        }
-        
-        throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.literalIncorrect().createWithContext(reader, this.literal);
-    }
-    
-    private __parse(reader: StringReader): number {
-        let start = reader.getCursor();
-        if (reader.canRead(this.literal.length)) {
-            let end = start + this.literal.length;
-            if (reader.getString().substring(start, end) === this.literal) {
-                reader.setCursor(end);
-                if (!reader.canRead() || reader.peek() == ' ') {
-                    return end;
-                }
-                else {
-                    reader.setCursor(start);
-                }                
-            }            
-        }        
-        return -1;
-    }
-    
-    public 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();
-        }
-        
-    }
-    
-    public isValidInput(input: string): boolean {
-        return this.__parse(new StringReader(input)) > -1;
-    }
-    
-    public equals(o: object): boolean {
-        if (this === o) return true;        
-        if (!(o instanceof  LiteralCommandNode)) return false;
-        
-        if (!(this.literal === o.literal)) return false;
-        
-        return super.equals(o);
-    }
-    
-    public getUsageText(): string {
-        return this.literal;
-    }
-    
-    public createBuilder(): LiteralArgumentBuilder<S> {
-        let builder: LiteralArgumentBuilder<S> = LiteralArgumentBuilder.literal(this.literal);
-        builder.requires(this.getRequirement());
-        builder.forward(this.getRedirect(), this.getRedirectModifier(), this.isFork());
-        if (this.getCommand() != null)
-            builder.executes(this.getCommand());    
-        
-        return builder;
-    }
-    
-    public getSortedKey(): string {
-        return this.literal;
-    }
-    
-    public getExamples(): Iterable<string> {
-		return [ this.literal ];
-    }
-    
-    public toString(): string {
-        return "<literal " + this.literal + ">";
-    }
-}

package/src/lib/tree/RootCommandNode.ts

@@ -1,62 +0,0 @@
-import CommandNode from "./CommandNode"
-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"
-
-export default class RootCommandNode<S> extends CommandNode<S> {
-    
-    public constructor () {
-        super(null, s => true, null, (s: CommandContext<S>) => s.getSource(), false);
-	}
-	
-	public getNodeType(): string {
-		return "root"
-	}
-    
-    public getName(): string {
-        return "";
-    }
-    
-    public getUsageText(): string {
-        return "";
-    }
-    
-    public parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>) {
-        
-    }
-    
-    public listSuggestions(context: CommandContext<S>, builder: SuggestionsBuilder): Promise<Suggestions> {
-        return Suggestions.empty();
-    }
-    
-    public isValidInput(input: String): boolean {
-        return false;
-    }
-    
-    public equals(o: object): boolean {
-
-		if (this === o) return true;
-        if (!(o instanceof RootCommandNode)) return false;
-        
-        return super.equals(o);
-    }
-    
-    public createBuilder(): ArgumentBuilder<S, any> {
-        throw new Error("Cannot convert root into a builder");
-    }
-    
-    public getSortedKey(): string {
-        return "";
-    }
-    
-    public getExamples(): Iterable<string> {
-        return [];
-    }
-    
-    public toString(): string {
-        return "<root>";
-    }
-}

package/src/lib/util/isEqual.ts

@@ -1,75 +0,0 @@
-export default function isEqual(a: any, b: any): boolean { // @Warning: May cause an infinite loop
-
-	if (a === b)
-		return true;
-
-	if (typeof a != typeof b)
-		return false;
-
-	if (!(a instanceof Object))
-		return false;	
-
-	if (typeof a === "function")
-		return a.toString() === b.toString();
-
-	if (a.constructor !== b.constructor)
-		return false;
-
-	if (a instanceof Map)
-		return isMapEqual(a, b);
-
-	if (a instanceof Set) 
-		return isArrayEqual([...a], [...b]);
-
-	if (a instanceof Array)
-		return isArrayEqual(a, b);
-
-	if (typeof a === "object")
-		return isObjectEqual(a, b);
-
-	return false;
-}
-
-function isMapEqual(a: Map<any, any>, b: Map<any, any>): boolean {
-
-	if (a.size != b.size) return false;
-
-	for (let [key, val] of a) {
-		const testVal = b.get(key);
-		if (!isEqual(testVal, val))
-			return false;
-        if (testVal === undefined && !b.has(key))
-            return false;    
-	}
-	
-	return true;
-}
-
-function isArrayEqual(a: Array<any>, b: Array<any>): boolean {
-
-	if (a.length != b.length) return false;
-
-	for(let i = 0; i < a.length; i++)
-		if (!isEqual(a[i], b[i]))
-			return false;
-
-	return true;
-}
-
-function isObjectEqual(a: TypicalObject, b: TypicalObject): boolean {
-
-	const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-
-    if (aKeys.length != bKeys.length) return false;
-    if (!aKeys.every(key => b.hasOwnProperty(key))) return false;
-
-    return aKeys.every((key: string) => {
-      return isEqual(a[key], b[key])
-    });
-}
-
-interface TypicalObject {
-	[ index: string ]: any;
-	[ index: number ]: any;
-};

package/test/CommandDispatcherTest.ts

@@ -1,427 +0,0 @@
-import { assert, expect } from "chai"
-import Command from "../src/lib/Command"
-import RedirectModifier from "../src/lib/RedirectModifier"
-import CommandDispatcher from "../src/lib/CommandDispatcher"
-import CommandSyntaxException from "../src/lib/exceptions/CommandSyntaxException"
-import { literal } from "../src/lib/builder/LiteralArgumentBuilder"
-import { argument } from "../src/lib/builder/RequiredArgumentBuilder"
-import { DefaultType } from "../src/lib/arguments/ArgumentType"
-import StringReader from "../src/lib/StringReader";
-
-const { integer } = DefaultType
-
-interface MockedCommand<S> extends Command<S> {
-	execHistory: object;
-	when(arg: any, returnValue: number): void;
-	verify(arg: any): number;
-}
-
-const createMockedCommand = (): MockedCommand<Object> => {
-	const execHistory = [];
-	const execCount = [];
-	const whenArg = new Map<any, number>();
-	const command = (arg): number => {
-		let i = execHistory.indexOf(arg);
-		if (i === -1) {
-			i = execCount.length;
-			execCount[i] = 0;
-			execHistory[i] = arg;
-		}
-		execCount[i]++;
-
-		if (whenArg.has(arg))
-			return whenArg.get(arg);
-
-		if (whenArg.has("anything"))
-			return whenArg.get("anything");
-
-		return 69;
-	}
-	command.verify = (arg) => {
-		let i = execHistory.indexOf(arg);
-		if (i > -1)
-			return execCount[i];
-		else if (arg === "anything") {
-			let result = 0;
-			execCount.forEach(v => result += v);
-			return result;
-		}
-	}
-	command.when = (o, r: number) => {
-		whenArg.set(o, r);
-	}
-	command.execHistory	= execHistory;
-	return command;	
-}
-
-describe('CommandDispatcherTest', () => {
-
-	let command;
-	let subject: CommandDispatcher<Object>;	
-	const source: Object = {};	
-
-	beforeEach(() => {
-		subject = new CommandDispatcher();
-
-		command = createMockedCommand();
-		command.when("anything", 42);
-	})
-
-	function inputWithOffset(input: string, offset: number): StringReader {
-		const result = new StringReader(input);
-		result.setCursor(offset);
-		return result;
-	}
-
-	it('testCreateAndExecuteCommand', () => {		
-		subject.register(literal("foo").executes(command));				
-        assert.equal(subject.execute("foo", source), 42);
-		assert.equal(command.verify("anything") === 1, true);
-    })
-
-    it('testCreateAndExecuteOffsetCommand', () => {		
-        subject.register(literal("foo").executes(command));
-        assert.equal(subject.execute(inputWithOffset("/foo", 1), source), 42);
-        assert.equal(command.verify("anything") === 1, true);
-    })
-
-    it('testCreateAndMergeCommands', () => {		
-        subject.register(literal("base").then(literal("foo").executes(command)));
-        subject.register(literal("base").then(literal("bar").executes(command)));
-
-        assert.equal(subject.execute("base foo", source), 42);
-        assert.equal(subject.execute("base bar", source), 42);
-        assert.equal(command.verify("anything") === 2, true);
-    })
-
-    it('testExecuteUnknownCommand', done => {		
-        subject.register(literal("bar"));
-        subject.register(literal("baz"));
-
-        try {
-            subject.execute("foo", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand());
-            assert.equal(ex.getCursor(), 0);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteImpermissibleCommand', done => {		
-        subject.register(literal("foo").requires(s => false));
-
-        try {
-            subject.execute("foo", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand());
-            assert.equal(ex.getCursor(), 0);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteEmptyCommand', done => {		
-        subject.register(literal(""));
-
-        try {
-            subject.execute("", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand());
-            assert.equal(ex.getCursor(), 0);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteUnknownSubcommand', done => {		
-        subject.register(literal("foo").executes(command));
-
-        try {
-            subject.execute("foo bar", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument());
-            assert.equal(ex.getCursor(), 4);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteIncorrectLiteral', done => {		
-        subject.register(literal("foo").executes(command).then(literal("bar")));
-
-        try {
-            subject.execute("foo baz", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument());
-            assert.equal(ex.getCursor(), 4);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteAmbiguousIncorrectArgument', done => {		
-        subject.register(
-            literal("foo").executes(command)
-                .then(literal("bar"))
-                .then(literal("baz"))
-        );
-
-        try {
-            subject.execute("foo unknown", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument());
-            assert.equal(ex.getCursor(), 4);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteSubcommand', () => {
-		const subCommand = createMockedCommand()		
-		subCommand.when("anything", 100);
-
-        subject.register(literal("foo").then(
-            literal("a")
-        ).then(
-            literal("=").executes(subCommand)
-        ).then(
-            literal("c")
-        ).executes(command));
-
-        assert.equal(subject.execute("foo =", source), 100);
-        assert.equal(subCommand.verify("anything") === 1, true);
-    })
-
-    it('testParseIncompleteLiteral', () => {		
-        subject.register(literal("foo").then(literal("bar").executes(command)));
-
-        const parse = subject.parse("foo ", source);
-        assert.equal(parse.getReader().getRemaining(), " ");
-        assert.equal(parse.getContext().getNodes().length, 1);
-    })
-
-    it('testParseIncompleteArgument', () => {		
-        subject.register(literal("foo").then(argument("bar", integer()).executes(command)));
-
-        const parse = subject.parse("foo ", source);
-        assert.equal(parse.getReader().getRemaining(), " ");
-        assert.equal(parse.getContext().getNodes().length, 1);
-    })
-
-    it('testExecuteAmbiguiousParentSubcommand', () => {		
-        const subCommand = createMockedCommand()		
-		subCommand.when("anything", 100);
-
-        subject.register(
-            literal("test")
-                .then(
-                    argument("incorrect", integer())
-                        .executes(command)
-                )
-                .then(
-                    argument("right", integer())
-                        .then(
-                            argument("sub", integer())
-                                .executes(subCommand)
-                        )
-                )
-        );
-
-        assert.equal(subject.execute("test 1 2", source), 100);
-        assert.equal(subCommand.verify("anything") > 0, true);
-        assert.equal(command.verify("anything") === 0, true);
-    })
-
-    it('testExecuteAmbiguiousParentSubcommandViaRedirect', () => {		
-        const subCommand = createMockedCommand()		
-		subCommand.when("anything", 100);
-
-        const real = subject.register(
-            literal("test")
-                .then(
-                    argument("incorrect", integer())
-                        .executes(command)
-                )
-                .then(
-                    argument("right", integer())
-                        .then(
-                            argument("sub", integer())
-                                .executes(subCommand)
-                        )
-                )
-        );
-
-        subject.register(literal("redirect").redirect(real));
-
-        assert.equal(subject.execute("redirect 1 2", source), 100);
-        assert.equal(subCommand.verify("anything") > 0, true);
-        assert.equal(command.verify("anything") === 0, true);
-    })
-
-    it('testExecuteRedirectedMultipleTimes', () => {		
-        const concreteNode = subject.register(literal("actual").executes(command));
-        const redirectNode = subject.register(literal("redirected").redirect(subject.getRoot()));
-
-        const input = "redirected redirected actual";
-
-        const parse = subject.parse(input, source);
-        assert.equal(parse.getContext().getRange().get(input), "redirected");
-        assert.equal(parse.getContext().getNodes().length, 1);
-        assert.equal(parse.getContext().getRootNode(), subject.getRoot());
-        expect(parse.getContext().getNodes()[0].getRange()).to.deep.equal(parse.getContext().getRange());
-        assert.equal(parse.getContext().getNodes()[0].getNode(), redirectNode);
-
-        const child1 = parse.getContext().getChild();
-        expect(child1).to.not.equal(null)
-        assert.equal(child1.getRange().get(input), "redirected");
-        assert.equal(child1.getNodes().length, 1);
-        assert.equal(child1.getRootNode(), subject.getRoot());
-        expect(child1.getNodes()[0].getRange()).to.deep.equal(child1.getRange());
-        assert.equal(child1.getNodes()[0].getNode(), redirectNode);
-
-        const child2 = child1.getChild();
-        expect(child2).to.not.equal(null)
-        assert.equal(child2.getRange().get(input), "actual");
-        assert.equal(child2.getNodes().length, 1);
-        assert.equal(child2.getRootNode(), subject.getRoot());
-        expect(child2.getNodes()[0].getRange()).to.deep.equal(child2.getRange());
-        assert.equal(child2.getNodes()[0].getNode(), concreteNode);
-
-        assert.equal(subject.execute(parse), 42);
-        assert.equal(command.verify("anything") > 0, true);
-    })
-
-    it('testExecuteRedirected', () => {		
-		const source1 = { name: "Obj1" };
-		const source2 = { name: "Obj2" };
-        const mockedModifier: RedirectModifier<Object> = {
-			apply(obj) {
-				if (obj.getSource() === source)
-					return [source1, source2]
-			}
-		}
-
-        const concreteNode = subject.register(literal("actual").executes(command));
-        const redirectNode = subject.register(literal("redirected").fork(subject.getRoot(), mockedModifier));
-
-        const input = "redirected actual";
-        const parse = subject.parse(input, source);
-        assert.equal(parse.getContext().getRange().get(input), "redirected");
-        assert.equal(parse.getContext().getNodes().length, 1);
-        assert.equal(parse.getContext().getRootNode(), subject.getRoot());
-        expect(parse.getContext().getNodes()[0].getRange()).to.deep.equal(parse.getContext().getRange());
-        assert.equal(parse.getContext().getNodes()[0].getNode(), redirectNode);
-        assert.equal(parse.getContext().getSource(), source);
-
-        const parent = parse.getContext().getChild();
-        expect(parent).to.not.equal(null);
-        assert.equal(parent.getRange().get(input), "actual");
-        assert.equal(parent.getNodes().length, 1);
-        assert.equal(parse.getContext().getRootNode(), subject.getRoot());
-        expect(parent.getNodes()[0].getRange()).to.deep.equal(parent.getRange());
-        assert.equal(parent.getNodes()[0].getNode(), concreteNode);
-        assert.equal(parent.getSource(), source);
-		assert.equal(subject.execute(parse), 2);
-
-		let flag1 = 0, flag2 = 0;
-		command.execHistory.forEach(v => {
-			if (v.source === source1) flag1++;
-			if (v.source === source2) flag2++;
-		})
-		if (flag1 === 0 || flag2 === 0)
-			assert.fail();
-    })
-
-    it('testExecuteOrphanedSubcommand', done => {		
-        subject.register(literal("foo").then(
-            argument("bar", integer())
-        ).executes(command));
-
-        try {
-            subject.execute("foo 5", source);
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand());
-            assert.equal(ex.getCursor(), 5);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecute_invalidOther', () => {		
-		const wrongCommand = createMockedCommand();
-
-        subject.register(literal("w").executes(wrongCommand));
-        subject.register(literal("world").executes(command));
-
-        assert.equal(subject.execute("world", source), 42);
-        assert.equal(wrongCommand.verify("anything") === 0, true);
-        assert.equal(command.verify("anything") > 0, true);
-    })
-
-    it('parse_noSpaceSeparator', done => {		
-        subject.register(literal("foo").then(argument("bar", integer()).executes(command)));
-
-        try {
-            subject.execute("foo$", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand());
-            assert.equal(ex.getCursor(), 0);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testExecuteInvalidSubcommand', done => {		
-        subject.register(literal("foo").then(
-            argument("bar", integer())
-        ).executes(command));
-
-        try {
-            subject.execute("foo bar", source);            
-        } catch (ex) {
-            assert.equal(ex.getType(), CommandSyntaxException.BUILT_IN_EXCEPTIONS.readerExpectedInt());
-            assert.equal(ex.getCursor(), 4);
-            done();
-            return;
-        }
-
-        assert.fail();
-    })
-
-    it('testGetPath', () => {
-        const bar = literal("bar").build();
-        subject.register(literal("foo").then(bar));
-
-        expect(subject.getPath(bar)).to.deep.equal(["foo", "bar"]);
-    })
-
-    it('testFindNodeExists', () => {
-        const bar = literal("bar").build();
-        subject.register(literal("foo").then(bar));
-
-        assert.equal(subject.findNode(["foo", "bar"]), bar);
-    })
-
-    it('testFindNodeDoesntExist', () => {
-        expect(subject.findNode(["foo", "bar"])).to.equal(null);
-    })
-})
-
-