feat: add new context command to make it easier to work with multiple files (#14)

Author: Souvikns

README.md

@@ -23,9 +23,19 @@ Usage
 Commands
   validate 
    Options
-     -c --context  Your AsyncAPI specification
+     -c --context  context-name saved in the store
      -w --watch Enable watchMode (not implemented yet)
+  
+  context
+    current show the current set context
+    list show the list of all stored contexts
+    remove <context-name> remove a context from the store
+    use <context-name> set any context from store as current
+    add <context-name> <filepath> add/update new context
 
 Examples
-  $ asyncapi validate --context=specification.yml
+  $ asyncapi context add dummy ./asyncapi.yml
+	  $ asyncapi validate --context=dummy
 ```
+
+> For now --context flag is requried to run validate command

src/CliModels.ts

@@ -1,6 +1,7 @@
 
 export type Command = string;
 export type HelpMessage = string;
+export type Arguments = string[];
 
 export interface Options {
   context: string,
@@ -10,12 +11,12 @@ export interface Options {
 export class CliInput {
   private readonly _command: Command
   private readonly _options: Options
-  private readonly _helpMessage: HelpMessage
+  private readonly _arguments: Arguments
 
-  private constructor(command: Command, options: Options, helpMessage: HelpMessage) {
+  private constructor(command: Command, options: Options, args: Arguments) {
     this._command = command;
     this._options = options;
-    this._helpMessage = helpMessage;
+    this._arguments = args;
   }
 
   get command(): Command {
@@ -26,14 +27,20 @@ export class CliInput {
     return this._options;
   }
 
-  get helpMessage(): HelpMessage {
-    return this._helpMessage;
+
+  get arguments(): Arguments {
+    return this._arguments;
   }
 
   static createFromMeow(meowOutput: any): CliInput {
-    const [command] = meowOutput.input;
-    const help = meowOutput.help;
+    const [command, ...args] = meowOutput.input;
     const { context, watch } = meowOutput.flags;
-    return new CliInput(command || 'help', { context, watch }, help);
+    return new CliInput(command || 'help', { context, watch }, args);
+  }
+
+  static createSubCommand(cliInput: CliInput): CliInput {
+    const [command, ...args] = cliInput.arguments;
+    return new CliInput(command || 'help', cliInput.options, args);
   }
 }
+

src/CommandsRouter.spec.tsx

@@ -23,7 +23,7 @@ describe('CommandsRouter should', () => {
 
     setTimeout(() => {
       expect(lastFrame()).toBe(chalk.green(`File: ${file.getSpecificationName()} successfully validated!`));
-      done();
     }, 200);
+    done();
   });
 });

src/CommandsRouter.tsx

@@ -1,14 +1,16 @@
 import React from "react";
 import Validate from "./components/Validate/Validate";
+import { contextRouter } from './components/Context';
 import { CliInput } from "./CliModels";
 
-
 const commandsDictionary = (cliInput: CliInput) => ({
-  ['validate']: <Validate options={cliInput.options}/>,
+  ['validate']: <Validate options={cliInput.options} />,
+  ['context']: contextRouter(cliInput)
 });
 
 export const commandsRouter = (cli: any) => {
   const cliInput = CliInput.createFromMeow(cli);
-  // @ts-ignore
+
+  //@ts-ignore
   return commandsDictionary(cliInput)[cliInput.command];
 };

src/cli.ts

@@ -12,17 +12,24 @@ const cli = meow(`
 	Commands
 		validate 
 			Options
-				-c --context  Your AsyncAPI specification
+				-c --context  context-name saved in the store
 				-w --watch Enable watchMode (not implemented yet)
+		context
+			current  show the current set context
+			list     show the list of all stored context
+			remove  <context-name> remove a context from the store
+			use <context-name>  set any context as current
+			add <context-name> <filepath> add/update new context
 
 	Examples
-	  $ asyncapi validate --context=specification.yml
+	  $ asyncapi context add dummy ./asyncapi.yml
+	  $ asyncapi validate --context=dummy
 `, {
 	flags: {
 		context: {
 			alias: 'c',
 			type: 'string',
-			isRequired: true
+			isRequired: false
 		},
 		watch: {
 			alias: 'w',

src/components/Context/Context.tsx

@@ -0,0 +1,87 @@
+import { useContextFile } from '../../hooks/context';
+import React, { FunctionComponent } from 'react';
+import { Box, Text } from 'ink';
+import ContextError from './contexterror';
+import { SpecificationFile } from '../../hooks/validation';
+
+export const ListContexts: FunctionComponent = () => {
+	const { response, error } = useContextFile().list();
+
+	if (error) {
+		return <ContextError error={error} />
+	}
+
+	if (response) {
+		return <Box flexDirection="column">
+			{response.map((context: any) => <Text key={context.key}>{context.key} : {context.path}</Text>)}
+		</Box>
+	}
+
+	return <></>
+}
+
+export const ShowCurrentContext: FunctionComponent = () => {
+	const { response, error } = useContextFile().current();
+
+	if (error) {
+		return <ContextError error={error} />
+	}
+
+	if (response) {
+		return <Text>{response.key} : {response.path}</Text>
+	}
+
+	return <></>
+}
+
+export const AddContext: FunctionComponent<{ options: any, args: string[] }> = ({ args }) => {
+	const [key, path] = args
+
+	if (!key || !path) {
+		return <ContextError error={new Error("missing arguments")} />
+	}
+
+	const { response, error } = useContextFile().addContext(key, new SpecificationFile(path));
+
+	if (error) {
+		return <ContextError error={error} />
+	}
+
+	return <Text>{response}</Text>
+}
+
+export const SetCurrent: FunctionComponent<{ options: any, args: string[] }> = ({ args }) => {
+	const [key,] = args;
+
+	if (!key) {
+		return <ContextError error={new Error("missing arguments")} />
+	}
+
+	const { response, error } = useContextFile().setCurrent(key);
+
+	if (error) {
+		return <ContextError error={error} />
+	}
+
+	if (response) {
+		return <Text>{response.key} : {response.path}</Text>
+	}
+
+	return <></>
+}
+
+export const RemoveContext: FunctionComponent<{ options: any, args: string[] }> = ({ args }) => {
+	const [key] = args;
+
+	if (!key) {
+		return <ContextError error={new Error("missing arguments")} />
+	}
+
+	const { response, error } = useContextFile().deleteContext(key);
+
+	if (error) {
+		return <ContextError error={error} />
+	}
+
+	return <Text>{response}</Text>
+}

src/components/Context/context.spec.tsx

@@ -0,0 +1,60 @@
+import React from 'react';
+import { render } from 'ink-testing-library';
+import { ListContexts, ShowCurrentContext, AddContext, SetCurrent } from './Context';
+import { ContextTestingHelper } from '../../constants';
+
+let testing = new ContextTestingHelper();
+
+describe('listing contexts', () => {
+	test("should render error when no context file found", () => {
+		testing.deleteDummyContextFile();
+		let { lastFrame } = render(<ListContexts />);
+		expect(lastFrame()).toMatch("No contexts saved yet.");
+	})
+
+	test("Should render the context list", () => {
+		testing.createDummyContextFile()
+		let { lastFrame } = render(<ListContexts />);
+		expect(lastFrame()).toMatch(
+			`home : ${testing.context.store["home"]}\n` +
+			`code : ${testing.context.store["code"]}`
+		);
+	})
+})
+
+describe('rendering current context', () => {
+	test('showing error if now current context is found', () => {
+		testing.deleteDummyContextFile();
+		let { lastFrame } = render(<ShowCurrentContext />);
+		expect(lastFrame()).toMatch('No contexts saved yet.');
+	})
+
+	test('showing current context ', () => {
+		testing.createDummyContextFile();
+		let { lastFrame } = render(<ShowCurrentContext />);
+		expect(lastFrame()).toMatch(`home : ${testing.context.store["home"]}`);
+	})
+})
+
+describe('AddContext ', () => {
+	test("should return message", () => {
+		testing.createDummyContextFile();
+		let { lastFrame } = render(<AddContext options={{}} args={['home', './test/specification.yml']} />);
+		expect(lastFrame()).toMatch('New context added');
+	})
+})
+
+describe('SetContext ', () => {
+
+	test('Should render error message is key is not in store', () => {
+		testing.createDummyContextFile();
+		let { lastFrame } = render(<SetCurrent args={['name']} options={{}} />)
+		expect(lastFrame()).toMatch('The context you are trying to use is not present');
+	});
+
+	test('Should render the update context', () => {
+		testing.createDummyContextFile();
+		let { lastFrame } = render(<SetCurrent args={['code']} options={{}} />)
+		expect(lastFrame()).toMatch(`code : ${testing.context.store['code']}`);
+	});
+})

src/components/Context/contexterror.tsx

@@ -0,0 +1,22 @@
+import React, { FunctionComponent } from 'react';
+import { Text } from 'ink';
+import { ContextFileNotFoundError, DeletingCurrentContextError, KeyNotFoundError } from '../../hooks/context';
+
+const ContextError: FunctionComponent<{ error: Error }> = ({ error }) => {
+
+	if (error instanceof ContextFileNotFoundError) {
+		return <Text>No contexts saved yet.</Text>
+	}
+
+	if(error instanceof KeyNotFoundError){
+		return <Text>The context you are trying to use is not present</Text>
+	}
+
+	if(error instanceof DeletingCurrentContextError) {
+		return <Text>You are trying to delete a context that is set as current.</Text>
+	}
+
+	return <Text>{error.message}</Text>
+};
+
+export default ContextError;

src/components/Context/index.tsx

@@ -0,0 +1,18 @@
+import React from 'react';
+import { CliInput } from '../../CliModels';
+import { ListContexts,AddContext,RemoveContext,ShowCurrentContext,SetCurrent } from './Context';
+
+//@ts-ignore
+const commandDictionary = (cliInput: CliInput) => ({
+	['list']: <ListContexts />,
+	['current']: <ShowCurrentContext />,
+	['use']: <SetCurrent options={cliInput.options} args={cliInput.arguments} />,
+	['add']: <AddContext options={cliInput.options} args={cliInput.arguments} />,
+	['remove']: <RemoveContext options={cliInput.options} args={cliInput.arguments} />
+})
+
+export const contextRouter = (cliInput: CliInput) => {
+	let subCommand = CliInput.createSubCommand(cliInput);
+	//@ts-ignore
+	return commandDictionary(subCommand)[subCommand.command];
+}

src/components/Validate/Validate.spec.tsx

@@ -5,6 +5,8 @@ import { Options } from "../../CliModels";
 import { UseValidateResponse } from "../../hooks/validation/models";
 import chalk from "chalk";
 import * as validationHook from '../../hooks/validation';
+import { ContextTestingHelper } from '../../constants';
+
 
 
 function makeUseValidateReturn(response: UseValidateResponse) {
@@ -14,13 +16,16 @@ function makeUseValidateReturn(response: UseValidateResponse) {
 }
 
 function renderValidationComponentWith(options: Options) {
-  return render(<Validate options={options}/>);
+  return render(<Validate options={options} />);
 }
 
+const testing = new ContextTestingHelper();
+
 describe('Validate component should', () => {
   test('render the success message in green color when the specification is correct', (done) => {
+    testing.createDummyContextFile();
     const options: Options = {
-      context: 'oneFile.yml',
+      context: 'home',
       watch: false,
     };
 
@@ -35,8 +40,9 @@ describe('Validate component should', () => {
   });
 
   test('render the single error message in red color when the file is not valid', (done) => {
+    testing.createDummyContextFile();
     const options: Options = {
-      context: 'oneFile.yml',
+      context: 'home',
       watch: false,
     };
 
@@ -51,8 +57,9 @@ describe('Validate component should', () => {
   });
 
   test('render the different error messages in red color when the validation fails', (done) => {
+    testing.createDummyContextFile();
     const options: Options = {
-      context: 'oneFile.yml',
+      context: 'home',
       watch: false,
     };