feat(core): synonymize "open" and "connect to"

pkg/core/src/parser.ts

@@ -3,6 +3,7 @@ import {
 	And,
 	Buzzword,
 	Connect,
+	Open,
 	Identifier,
 	Into,
 	Output,
@@ -14,14 +15,14 @@ import { CstParser, type IToken, type CstNode } from '@slangroom/deps/chevrotain
 
 export type StatementCst = CstNode & {
 	children: {
-		connect?: ConnectCst;
+		openconnect?: OpenconnectCst;
 		sendpass: SendpassCst[];
 		phrase: PhraseCst;
 		into?: IntoCst;
 	};
 };
 
-export type ConnectCst = CstNode & {
+export type OpenconnectCst = CstNode & {
 	children: { Identifier: [IToken] };
 };
 
@@ -49,15 +50,22 @@ const Parser = new (class extends CstParser {
 	}
 
 	statement = this.RULE('statement', () => {
-		this.OPTION1(() => this.SUBRULE(this.#connect));
+		this.OPTION1(() => this.SUBRULE(this.#openconnect));
 		this.MANY(() => this.SUBRULE(this.#sendpass));
 		this.SUBRULE(this.#phrase);
 		this.OPTION2(() => this.SUBRULE(this.#into));
 	});
 
-	#connect = this.RULE('connect', () => {
-		this.CONSUME(Connect);
-		this.CONSUME(To);
+	#openconnect = this.RULE('openconnect', () => {
+		this.OR([
+			{ ALT: () => this.CONSUME(Open) },
+			{
+				ALT: () => {
+					this.CONSUME(Connect);
+					this.CONSUME(To);
+				},
+			},
+		]);
 		this.CONSUME(Identifier);
 		this.CONSUME(And);
 	});

pkg/core/src/plugin.ts

@@ -43,21 +43,33 @@
 	phrase: string;
 
 	/**
-	 * Gets the value of the Connect part of a Statement« if available.
+	 * Gets the value of the Open or Connect part of a Statement, if available.
 	 *
-	 * @returns The array of values of the Connect part (might be empty).
+	 * @returns The array of values of the Open or Connect part (might be
+	 * empty).
 	 */
 	getConnect(): string[];
 
 	/**
 	 * Basically the same as {@link getConnect}, but throws if unavailable or empty.
 	 *
-	 * @returns The array of values of the Connect part (has at least one item);
+	 * @returns The array of values of the Open or Connect part (has at least
+	 * one item).
 	 *
 	 * @throws {@link Error} if the part is unavailable.
 	 */
 	fetchConnect(): [string, ...string[]];
 
+	/**
+	 * {@inheritDoc getConnect}
+	 */
+	getOpen(): string[];
+
+	/**
+	 * {@inheritDoc fetchConnect}
+	 */
+	fetchOpen(): [string, ...string[]];
+
 	/**
 	 * Gets the value of the parameter needed by the Plugin, if available.
 	 *
@@ -106,10 +118,10 @@
 	readonly phrase: string;
 
 	/**
-	 * The name of the identifier used to reference the Connection parameters
-	 * (via {@link #zparams}).  It is an rhs value.
+	 * The name of the identifier used to reference the Open or Connect
+	 * parameters (via {@link #zparams}).  It is an rhs value.
 	 */
-	#connect: string | undefined = undefined;
+	#openconnect: string | undefined = undefined;
 
 	/**
 	 * A map between parameters that should be provided to a statetment and
@@ -129,7 +141,7 @@
 
 	constructor(stmt: Statement, zparams: ZenParams) {
 		this.phrase = stmt.phrase.toLowerCase();
-		this.#connect = stmt.connect;
+		this.#openconnect = stmt.openconnect;
 		this.#bindings = stmt.bindings;
 		this.#zparams = zparams;
 	}
@@ -159,14 +171,14 @@
 	 * {@inheritDoc PluginContext.getConnect}
 	 */
 	getConnect(): string[] {
-		if (!this.#connect) return [];
-		const val = this.#getDataKeys(this.#connect);
+		if (!this.#openconnect) return [];
+		const val = this.#getDataKeys(this.#openconnect);
 		if (typeof val === 'string') return [val];
 		if (Array.isArray(val)) {
 			if (val.every((x) => typeof x === 'string')) return val as string[];
 			else
 				throw new Error(
-					`the array referenced by ${this.#connect} must solely composed of strings`
+					`the array referenced by ${this.#openconnect} must solely composed of strings`
 				);
 		}
 		return [];
@@ -181,6 +193,20 @@
 		return val as [string, ...string[]];
 	}
 
+	/**
+	 * {@inheritDoc PluginContext.getOpen}
+	 */
+	getOpen(): string[] {
+		return this.getConnect();
+	}
+
+	/**
+	 * {@inheritDoc PluginContext.fetchOpen}
+	 */
+	fetchOpen(): [string, ...string[]] {
+		return this.fetchConnect();
+	}
+
 	/**
 	 * {@inheritDoc PluginContext.get}
 	 */
@@ -210,22 +236,30 @@
  * @internal
  */
 export class PluginContextTest implements PluginContext {
-	#connect: string[] = [];
+	#openconnect: string[] = [];
 	#params = new Map<string, Jsonable>();
 	readonly phrase: string = ''; // not used but required by the interface
 
-	constructor(connect: string | string[], params: Record<string, Jsonable>) {
-		this.#connect = typeof connect === 'string' ? [connect] : connect;
+	constructor(openconnect: string | string[], params: Record<string, Jsonable>) {
+		this.#openconnect = typeof openconnect === 'string' ? [openconnect] : openconnect;
 		this.#params = new Map(Object.entries(params));
 	}
 
+	/**
+	 * @constructor
+	 */
+	static open(open: string | string[]) {
+		return new this(open, {});
+	}
+
 	/**
 	 * @constructor
 	 */
 	static connect(connect: string | string[]) {
 		return new this(connect, {});
 	}
 
+
 	/**
 	 * @constructor
 	 */
@@ -251,7 +285,7 @@
 	 * {@inheritDoc PluginContext.getConnect}
 	 */
 	getConnect(): string[] {
-		return this.#connect;
+		return this.#openconnect;
 	}
 
 	/**
@@ -263,6 +297,20 @@
 		return val as [string, ...string[]];
 	}
 
+	/**
+	 * {@inheritDoc PluginContext.getOpen}
+	 */
+	getOpen(): string[] {
+		return this.getConnect();
+	}
+
+	/**
+	 * {@inheritDoc PluginContext.fetchOpen}
+	 */
+	fetchOpen(): [string, ...string[]] {
+		return this.fetchConnect();
+	}
+
 	/**
 	 * {@inheritDoc PluginContext.get}
 	 */

pkg/core/src/tokens.ts

@@ -18,6 +18,11 @@ export const Connect = createToken({
 	pattern: /connect/i,
 });
 
+export const Open = createToken({
+	name: 'Open',
+	pattern: /open/i,
+});
+
 export const To = createToken({
 	name: 'To',
 	pattern: /to/i,
@@ -51,6 +56,7 @@ export const And = createToken({
 export const allTokens = [
 	Whitespace,
 	Connect,
+	Open,
 	Into,
 	Output,
 	And,

pkg/core/src/visitor.ts

@@ -4,12 +4,12 @@ import {
 	type PhraseCst,
 	type IntoCst,
 	type SendpassCst,
-	type ConnectCst,
+	type OpenconnectCst,
 } from '@slangroom/core';
 import type { IToken } from '@slangroom/deps/chevrotain';
 
 export type Statement = {
-	connect?: string;
+	openconnect?: string;
 	bindings: Map<string, string>;
 	phrase: string;
 	into?: string;
@@ -27,7 +27,7 @@ interface V {
 	visit(cst: StatementCst): ReturnType<this['statement']>;
 	visit(cst: PhraseCst): ReturnType<this['phrase']>;
 	visit(cst: SendpassCst): ReturnType<this['sendpass']>;
-	visit(cst: ConnectCst): ReturnType<this['connect']>;
+	visit(cst: OpenconnectCst): ReturnType<this['openconnect']>;
 	visit(cst: IntoCst): ReturnType<this['into']>;
 }
 
@@ -47,7 +47,7 @@ class V extends CstVisitor {
 			if (stmt.bindings.has(key)) throw new ErrorKeyExists(key);
 			stmt.bindings.set(key, value);
 		});
-		if (ctx.connect) stmt.connect = this.visit(ctx.connect);
+		if (ctx.openconnect) stmt.openconnect = this.visit(ctx.openconnect);
 		if (ctx.into) stmt.into = this.visit(ctx.into);
 		return stmt;
 	}
@@ -60,7 +60,7 @@ class V extends CstVisitor {
 		return [this.visit(ctx.phrase), ctx.Identifier[0].image.slice(1, -1)];
 	}
 
-	connect(ctx: ConnectCst['children']): string {
+	openconnect(ctx: OpenconnectCst['children']): string {
 		return ctx.Identifier[0].image.slice(1, -1);
 	}
 

pkg/core/test/slangroom.ts

@@ -5,6 +5,8 @@ test('runs all unknown statements', async (t) => {
 	let usedP0 = false;
 	let usedP1 = false;
 	let usedP2 = false;
+	let usedP3 = false;
+	let usedP4 = false;
 
 	const p0 = (ctx: PluginContext): PluginResult => {
 		if (ctx.phrase === 'a') {
@@ -32,6 +34,25 @@ test('runs all unknown statements', async (t) => {
 		return ctx.fail('Unkown phrase');
 	};
 
+	const p3 = (ctx: PluginContext): PluginResult => {
+		if (ctx.phrase === 'e f') {
+			usedP3 = true;
+			t.is(ctx.fetchOpen()[0], 'bar');
+			return ctx.pass(null);
+		}
+		return ctx.fail('Unkown phrase');
+	};
+
+	const p4 = (ctx: PluginContext): PluginResult => {
+		if (ctx.phrase === 'f g') {
+			usedP4 = true;
+			t.is(ctx.fetchConnect()[0], 'foo');
+			return ctx.pass(null);
+		}
+		return ctx.fail('Unkown phrase');
+	};
+
+
 	const script = `
 Rule caller restroom-mw
 Given I A and output into 'a'
@@ -42,11 +63,15 @@ Then print 'a'
 Then I pass a 'a' and B and output into 'b'
 Then I pass a 'b' and  c D
 Then I pass a 'b' and  C d and output into 'mimmo'
+Then I open 'b' and e F
+Then I connect to 'a' and F g
 `;
-	const slangroom = new Slangroom(p0, [p1, new Set([p2])]);
+	const slangroom = new Slangroom(p0, [p1, new Set([p2]), p3], p4);
 	const res = await slangroom.execute(script);
 	t.true(usedP0);
 	t.true(usedP1);
 	t.true(usedP2);
+	t.true(usedP3);
+	t.true(usedP4);
 	t.deepEqual(res.result, { a: 'foo', b: 'bar', mimmo: 'foobar' }, res.logs);
 });

pkg/core/test/visitor.ts

@@ -21,29 +21,29 @@ test('generated ast is correct', async (t) => {
 			]),
 		},
 		"connect to 'foo' and read the    ethereum		 balance": {
-			connect: 'foo',
+			openconnect: 'foo',
 			phrase: 'read the ethereum balance',
 			bindings: new Map<string, string>(),
 		},
 		"connect to 'foo' and pass address 'addr'  and send contract 'contract' and read the    ethereum		 balance":
-			{
-				connect: 'foo',
-				phrase: 'read the ethereum balance',
-				bindings: new Map<string, string>([
-					['address', 'addr'],
-					['contract', 'contract'],
-				]),
-			},
-		"connect to 'foo' and pass address 'addr'  and send contract 'contract' and read the    ethereum		 balance and output into 'var'":
-			{
-				connect: 'foo',
-				phrase: 'read the ethereum balance',
-				bindings: new Map<string, string>([
-					['address', 'addr'],
-					['contract', 'contract'],
-				]),
-				into: 'var',
-			},
+		{
+			openconnect: 'foo',
+			phrase: 'read the ethereum balance',
+			bindings: new Map<string, string>([
+				['address', 'addr'],
+				['contract', 'contract'],
+			]),
+		},
+		"open 'foo' and pass address 'addr'  and send contract 'contract' and read the    ethereum		 balance and output into 'var'":
+		{
+			openconnect: 'foo',
+			phrase: 'read the ethereum balance',
+			bindings: new Map<string, string>([
+				['address', 'addr'],
+				['contract', 'contract'],
+			]),
+			into: 'var',
+		},
 	};
 
 	for (const [line, astWant] of Object.entries(cases)) {