5630256138

pending completion

Build # 5630256138

Build Type

push

github

Committed by

gturi

Commit Message

refactor get current alias function in a more functional way

Run Details

162 of 212 branches covered (76.42%)

Branch coverage included in aggregate %.

10 of 10 new or added lines in 1 file covered. (100.0%)

703 of 795 relevant lines covered (88.43%)

270.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.41

/src/validator/alias-validator.ts

import { NcaConfig } from "../config/nca-config";
import { Alias } from "../model/api/alias";
import { CommandType } from "../model/api/command-type";
import { OptionParam } from "../model/api/option-param";
import { PositionalArgument } from "../model/api/positional-argument";
import { ArrayUtils } from "../util/array-utils";
import { StringUtils } from "../util/string-utils";
import { DuplicatesValidator } from "./duplicates-validator";
import { EnumValidator } from "./enum-validator";
import { OptionParamValidator } from "./option-param-validator";
import { PositionalArgumentValidator } from "./positional-argument-validator";
import { WhiteSpaceValidator } from "./white-space-validator";

type Parent = {
  options: OptionParam[],
  positionalArguments: PositionalArgument[]
}

export class AliasValidator {

  static validate(aliases: Alias[]) {
    this.privateValidator(aliases, {
      options: [],
      positionalArguments: []
    });
  }

  private static privateValidator(aliases: Alias[], parent: Parent) {
    const aliasesNames = aliases.map(alias => alias.name);
    this.checkNamesFormat(aliasesNames);
    this.checkForDuplicateNames(aliasesNames);

    aliases.forEach(alias => this.validateAlias(alias, parent));
  }

  private static checkNamesFormat(aliasesNames: string[]) {
    WhiteSpaceValidator.validate(aliasesNames, elementsWithWhitespaces => {
      return `Alias names cannot contain whitespaces [${elementsWithWhitespaces}]`;
    });

    this.checkForbiddenNames(aliasesNames);
  }

  private static checkForbiddenNames(aliasesNames: string[]) {
    const forbiddenNames = NcaConfig.getForbiddenNames();
    const forbiddenNamesFound = aliasesNames.filter(element => forbiddenNames.includes(element));
    if (forbiddenNamesFound.length > 0) {
      throw new Error(`The following aliases names are not allowed: [${forbiddenNamesFound}]`);
    }
  }

  private static checkForDuplicateNames(aliasesNames: string[]) {
    const getErrorMessage = (duplicates: string[]) => {
      return `Multiple aliases has been defined with the same name: [${duplicates}]`;
    };

    DuplicatesValidator.validate(aliasesNames, getErrorMessage);
  }

  private static validateAlias(alias: Alias, parent: Parent) {
    this.validateCommand(alias);

    const options = ArrayUtils.concat(parent.options, alias.options);
    OptionParamValidator.validate(alias.name, options);

    const positionalArguments = ArrayUtils.concat(
      parent.positionalArguments, alias.positionalArguments
    );
    PositionalArgumentValidator.validate(alias.name, positionalArguments);

    this.checkSubAliasCommandType(alias);

    if (alias.subAliases) {
      this.checkSubAliasesAndPositionalArgumentNames(alias, positionalArguments);

      this.privateValidator(alias.subAliases, {
        options: options,
        positionalArguments: positionalArguments
      });
    }
  }

  private static validateCommand(alias: Alias) {
    if (StringUtils.isEmpty(alias.command) && (alias.subAliases ?? []).length == 0) {
      throw new Error(
        `Alias '${alias.name}' must define sub aliases when its command is not defined`
      );
    }
  }

  private static checkSubAliasesAndPositionalArgumentNames(
    alias: Alias, parentPositionalArguments: PositionalArgument[]
  ) {
    if (alias.subAliases && alias.positionalArguments) {
      const aliasMatch = alias.subAliases.find(subAlias => {
        return parentPositionalArguments.some(positionalArgument => {
          return positionalArgument.name === subAlias.name
        });
      });
      if (aliasMatch) {
        throw new Error(
          `Alias name '${aliasMatch.name}' cannot be used: ` +
          'a positional argument with the same name already exists'
        );
      }
    }
  }

  private static checkSubAliasCommandType(alias: Alias) {
    const getErrorMessage = () =>
      `Alias '${alias.name}' commandType '${alias.commandType}' is not valid: ` +
      `supported values are ${Object.keys(CommandType)}`;
    const commandType = alias.commandType ?? CommandType.Simple;
    EnumValidator.validate(CommandType, commandType, getErrorMessage)
  }
}

1	import { NcaConfig } from "../config/nca-config";	26✔
2	import { Alias } from "../model/api/alias";
3	import { CommandType } from "../model/api/command-type";	26✔
4	import { OptionParam } from "../model/api/option-param";
5	import { PositionalArgument } from "../model/api/positional-argument";
6	import { ArrayUtils } from "../util/array-utils";	26✔
7	import { StringUtils } from "../util/string-utils";	26✔
8	import { DuplicatesValidator } from "./duplicates-validator";	26✔
9	import { EnumValidator } from "./enum-validator";	26✔
10	import { OptionParamValidator } from "./option-param-validator";	26✔
11	import { PositionalArgumentValidator } from "./positional-argument-validator";	26✔
12	import { WhiteSpaceValidator } from "./white-space-validator";	26✔
13
14	type Parent = {
15	options: OptionParam[],
16	positionalArguments: PositionalArgument[]
17	}
18
19	export class AliasValidator {	26✔
20
21	static validate(aliases: Alias[]) {
22	this.privateValidator(aliases, {	26✔
23	options: [],
24	positionalArguments: []
25	});
26	}
27
28	private static privateValidator(aliases: Alias[], parent: Parent) {
29	const aliasesNames = aliases.map(alias => alias.name);	601✔
30	this.checkNamesFormat(aliasesNames);	126✔
31	this.checkForDuplicateNames(aliasesNames);	126✔
32
33	aliases.forEach(alias => this.validateAlias(alias, parent));	601✔
34	}
35
36	private static checkNamesFormat(aliasesNames: string[]) {
37	WhiteSpaceValidator.validate(aliasesNames, elementsWithWhitespaces => {	126✔
38	return `Alias names cannot contain whitespaces [${elementsWithWhitespaces}]`;	×
39	});
40
41	this.checkForbiddenNames(aliasesNames);	126✔
42	}
43
44	private static checkForbiddenNames(aliasesNames: string[]) {
45	const forbiddenNames = NcaConfig.getForbiddenNames();	126✔
46	const forbiddenNamesFound = aliasesNames.filter(element => forbiddenNames.includes(element));	601✔
47	if (forbiddenNamesFound.length > 0) {	126!
48	throw new Error(`The following aliases names are not allowed: [${forbiddenNamesFound}]`);	×
49	}
50	}
51
52	private static checkForDuplicateNames(aliasesNames: string[]) {
53	const getErrorMessage = (duplicates: string[]) => {	126✔
54	return `Multiple aliases has been defined with the same name: [${duplicates}]`;	×
55	};
56
57	DuplicatesValidator.validate(aliasesNames, getErrorMessage);	126✔
58	}
59
60	private static validateAlias(alias: Alias, parent: Parent) {
61	this.validateCommand(alias);	601✔
62
63	const options = ArrayUtils.concat(parent.options, alias.options);	601✔
64	OptionParamValidator.validate(alias.name, options);	601✔
65
66	const positionalArguments = ArrayUtils.concat(	601✔
67	parent.positionalArguments, alias.positionalArguments
68	);
69	PositionalArgumentValidator.validate(alias.name, positionalArguments);	601✔
70
71	this.checkSubAliasCommandType(alias);	601✔
72
73	if (alias.subAliases) {	600✔
74	this.checkSubAliasesAndPositionalArgumentNames(alias, positionalArguments);	100✔
75
76	this.privateValidator(alias.subAliases, {	100✔
77	options: options,
78	positionalArguments: positionalArguments
79	});
80	}
81	}
82
83	private static validateCommand(alias: Alias) {
84	if (StringUtils.isEmpty(alias.command) && (alias.subAliases ?? []).length == 0) {	601!
85	throw new Error(	×
86	`Alias '${alias.name}' must define sub aliases when its command is not defined`
87	);
88	}
89	}
90
91	private static checkSubAliasesAndPositionalArgumentNames(
92	alias: Alias, parentPositionalArguments: PositionalArgument[]
93	) {
94	if (alias.subAliases && alias.positionalArguments) {	100!
95	const aliasMatch = alias.subAliases.find(subAlias => {	100✔
96	return parentPositionalArguments.some(positionalArgument => {	200✔
97	return positionalArgument.name === subAlias.name	400✔
98	});
99	});
100	if (aliasMatch) {	100!
101	throw new Error(	×
102	`Alias name '${aliasMatch.name}' cannot be used: ` +
103	'a positional argument with the same name already exists'
104	);
105	}
106	}
107	}
108
109	private static checkSubAliasCommandType(alias: Alias) {
110	const getErrorMessage = () =>	601✔
111	`Alias '${alias.name}' commandType '${alias.commandType}' is not valid: ` +	1✔
112	`supported values are ${Object.keys(CommandType)}`;
113	const commandType = alias.commandType ?? CommandType.Simple;	601✔
114	EnumValidator.validate(CommandType, commandType, getErrorMessage)	601✔
115	}
116	}

gturi / nca / 5630256138

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous