Add RuleDuplicatedParams

src/config/entities/ScriptValidationRules.ts

@@ -73,4 +73,9 @@ export default class ScriptValidationRules implements IScriptValidationRules {
 	 * This rule fails if the script has no data type for the returned value
 	 */
 	public noReturnType: IValidationRuleConfig = new ValidationRuleConfig(true, true);
+
+	/**
+	 * This rule fails if the script has one or more duplicated params names
+	 */
+	public duplicatedParams: IValidationRuleConfig = new ValidationRuleConfig(true, true);
 }

src/config/interfaces/IScriptValidationRules.d.ts

@@ -13,4 +13,5 @@ export default interface IScriptValidationRules {
 	functionSignatureInDescription: IValidationRuleConfig;
 	noReturnDescription: IValidationRuleConfig;
 	noReturnType: IValidationRuleConfig;
+	duplicatedParams: IValidationRuleConfig;
 }

src/validation/RulesProvider.ts

@@ -4,6 +4,7 @@ import IScriptValidationRules from "../config/interfaces/IScriptValidationRules"
 import IValidationRuleConfig from "../config/interfaces/IValidationRuleConfig";
 import IRule from "./interfaces/IRule";
 import IRulesProvider from "./interfaces/IRulesProvider";
+import RuleDuplicateParam from "./rules/RuleDuplicatedParams";
 import RuleFunctionSignatureInDescription from "./rules/RuleFunctionSignatureInDescription";
 import RuleMismatchingArguments from "./rules/RuleMismatchingArguments";
 import RuleMismatchingFunctionName from "./rules/RuleMismatchingFunctionName";
@@ -31,6 +32,7 @@ export default class RulesProvider implements IRulesProvider {
 			new RuleFunctionSignatureInDescription(),
 			new RuleNoReturnDescription(),
 			new RuleNoReturnType(),
+			new RuleDuplicateParam(),
 		];
 	}
 
@@ -49,6 +51,7 @@ export default class RulesProvider implements IRulesProvider {
 			rules.functionSignatureInDescription,
 			rules.noReturnDescription,
 			rules.noReturnType,
+			rules.duplicatedParams,
 		];
 	}
 }

src/validation/rules/RuleDuplicatedParams.ts

@@ -0,0 +1,37 @@
+import IRule from "../interfaces/IRule";
+import IValidableScript from "../interfaces/IValidableScript";
+
+/**
+ * This rule checks if the script has some duplicate parameter
+ */
+export default class RuleDuplicatedParams implements IRule {
+	/**
+	 * Method to validate the rule
+	 * @param element The element to validate
+	 */
+	public isValid(element: IValidableScript): boolean {
+		const list = this._getDuplicatedParamsList(element);
+		return (list.length === 0);
+	}
+	/**
+	 * Method to generate a warning message in case the rule is invalid
+	 * @param element The element to validate
+	 */
+	public getWarnMessage(element: IValidableScript): string {
+		const list = this._getDuplicatedParamsList(element);
+		return `Script "${element.doc.name}" has duplicated ${list.join(", ")} arguments.`;
+	}
+
+	private _getDuplicatedParamsList(element: IValidableScript): string[] {
+		const set = new Set<string>();
+		const list: string[] = [];
+		for (const param of element.doc.params) {
+			if (set.has(param.name)) {
+				list.push(param.name);
+			} else {
+				set.add(param.name);
+			}
+		}
+		return list;
+	}
+}

tests/unit/validation/rules/RuleDuplicateParam.spec.ts

@@ -0,0 +1,56 @@
+import {
+	Expect,
+	Test,
+	TestFixture,
+} from "alsatian";
+
+import DocParam from "../../../../src/doc_models/DocParam";
+import RuleDuplicatedParams from "../../../../src/validation/rules/RuleDuplicatedParams";
+import MockValidableScript from "./__mock__/MockValidableScript.mock";
+
+/* tslint:disable:max-classes-per-file completed-docs */
+
+@TestFixture("RuleDuplicateParamFixture")
+export class RuleDuplicateParamFixture {
+
+	@Test("isValid")
+	public isValid() {
+		const vs = new MockValidableScript();
+		const p1 = new DocParam();
+		const p2 = new DocParam();
+		p1.name = "arg1";
+		p2.name = "arg2";
+		vs.doc.params.push(p1, p2);
+
+		const rule = new RuleDuplicatedParams();
+		Expect(rule.isValid(vs)).toBe(true);
+	}
+
+	@Test("isValid_not")
+	public isValid_not() {
+		const vs = new MockValidableScript();
+		const p1 = new DocParam();
+		const p2 = new DocParam();
+		p1.name = "arg1";
+		p2.name = "arg1";
+		vs.doc.params.push(p1, p2);
+
+		const rule = new RuleDuplicatedParams();
+		Expect(rule.isValid(vs)).toBe(false);
+	}
+
+	@Test("isValid")
+	public getWarnMessage() {
+		const vs = new MockValidableScript();
+		const p1 = new DocParam();
+		const p2 = new DocParam();
+		p1.name = "arg1";
+		p2.name = "arg1";
+		vs.doc.params.push(p1, p2);
+
+		const rule = new RuleDuplicatedParams();
+		const str = rule.getWarnMessage(vs);
+		Expect(str).toContain("foo");
+		Expect(str).toContain("arg1");
+	}
+}