feat(rules): natural-order rule

.scriptlintrc

@@ -1,3 +1,7 @@
 {
-	"strict": true
-}
+	"strict": true,
+	"rules": {
+		"alphabetic-order": false,
+		"natural-order": true
+	}
+}

README.md

@@ -29,7 +29,7 @@ Your `package.json`'s `"scripts"` section should…
 -   _abstract script names from their implementation (`test`, not `jest`)_
 -   _use namespaces to categorize scripts (`"test:unit": "jest"`)_
 -   _use `:` as a namespace separator_
--   _have the scripts in alphabetic order_
+-   _have the scripts in alphabetic or ["natural order"](https://github.com/peerigon/scriptlint/wiki/natural-order)
 -   _have a trigger script for all hooks (ex: if you have `prefoobar`, there must be a `foobar` script)_
 -   _use `camelCase` for all script names_
 -   _not alias `devDependencies` (no `"jest": "jest"`)_
@@ -89,6 +89,9 @@ href="https://github.com/peerigon/scriptlint/wiki/uses-allowed-namespace">uses-a
 <li><a
 href="https://github.com/peerigon/scriptlint/wiki/alphabetic-order">alphabetic-order</a>
 </li>
+<li><a
+href="https://github.com/peerigon/scriptlint/wiki/natural-order">natural-order</a>
+</li>
 <li><a href="https://github.com/peerigon/scriptlint/wiki/correct-casing">correct-casing</a>
 </li>
 <li><a href="https://github.com/peerigon/scriptlint/wiki/no-aliases">no-aliases</a>

package.json

@@ -27,8 +27,8 @@
     "other:selfupdate": "updtr",
     "other:watch": "nodemon -e js,ts --watch src --exec 'run-p build:dev'",
     "prepublishOnly": "run-p build",
-    "pretest": "run-s build",
     "start": "node dist/index.js",
+    "pretest": "run-s build",
     "test": "run-s test:exports test:lint test:types test:unit:ci test:self",
     "test:exports": "ts-unused-exports tsconfig.json --ignoreFiles src/index.ts",
     "test:lint": "eslint ./src ./tests --ext js,ts,tsx",
@@ -85,4 +85,4 @@
     "cosmiconfig": "^7.0.0",
     "detect-indent": "^6.0.0"
   }
-}
+}

src/cliConfig.ts

@@ -27,7 +27,8 @@ export default (argv: Array<string>): CliConfig => {
 
 	program.parse(argv);
 
-	const cliConfig: CliConfig = { packageFile };
+	// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+	const cliConfig: CliConfig = { packageFile: packageFile ?? process.cwd() };
 
 	if (program.fix !== undefined) {
 		cliConfig.fix = program.fix;

src/cliModule.ts

@@ -28,6 +28,7 @@ export default (argv: Array<string>) => {
 
 		const userConfig = loadUserConfig();
 		const cliConfig = loadCliConfig(argv);
+
 		const config = {
 			...DEFAULT_CONFIG,
 			...{ json: false },
@@ -51,7 +52,7 @@ export default (argv: Array<string>) => {
 			writePackageScripts,
 			readPackageScripts,
 		} = userPackageScriptContext(
-			makePackageFilePath(config.packageFile ?? process.cwd())
+			makePackageFilePath(config.packageFile)
 		);
 
 		const scripts = readPackageScripts(config.ignoreScripts);

src/constants.ts

@@ -8,7 +8,7 @@ export const DEFAULT_CONFIG: Config = {
 	fix: false,
 	json: false,
 	config: false,
-	packageFile: undefined,
+	packageFile: process.cwd(),
 	rules: {},
 	customRules: [],
 	ignoreScripts: [],

src/defaultRuleSets.ts

@@ -1,14 +1,21 @@
 import defaultRules from "./rules";
 import { Rule } from "./types";
 
+export const optionalRules = ["natural-order"];
+
+const strict = defaultRules
+	.map((r: Rule) => r.name)
+	.filter((r) => !optionalRules.includes(r));
+
 const ruleSets = {
 	default: [
 		"mandatory-test",
 		"mandatory-start",
 		"mandatory-dev",
 		"no-default-test",
 	],
-	strict: defaultRules.map((r: Rule) => r.name),
+	strict,
+	optionalRules,
 };
 
 export default ruleSets;

src/loadRules.ts

@@ -1,4 +1,4 @@
-import defaultRuleSets from "./defaultRuleSets";
+import defaultRuleSets, {optionalRules} from "./defaultRuleSets";
 import defaultRules from "./rules";
 // Types
 import { Rule } from "./types";
@@ -32,31 +32,36 @@ const loadDefaultRulesFromSet = (strict: boolean): Array<Rule> => {
 		.filter((r): r is Rule => r !== null);
 };
 
+const loadOptionalRules = (): Array<Rule> => {
+	return optionalRules
+		.map((name: string) => getRuleByName(defaultRules, name))
+		.filter((r): r is Rule => r !== null);
+};
+
 export const loadRulesFromRuleConfig = (
 	strict: boolean,
 	rulesConfig?: RulesConfig,
 	customRules?: Array<Rule>
 ): Array<Rule> => {
+	const optionalRules = loadOptionalRules();
 	const rules = loadDefaultRulesFromSet(strict);
 
-	const loadedCustomRules =
-		rulesConfig && customRules
-			? customRules.filter((cr: Rule) => rulesConfig[cr.name])
-			: [];
-
-	const loadedRules = [...loadedCustomRules, ...rules];
-
+	// standard rulesets apply
 	if (!rulesConfig) {
-		return loadedRules;
+		return rules;
 	}
 
-	return loadedRules
-		.map((rule: Rule) => {
-			if (rule.name in rulesConfig && rulesConfig[rule.name] === false) {
-				return null;
-			}
+	// there's custom rules loaded
+	const loadedCustomRules = customRules
+		? customRules.filter((cr: Rule) => rulesConfig[cr.name])
+		: [];
 
-			return rule;
-		})
-		.filter((r): r is Rule => r !== null);
+	// there's enabled optional rules
+	const enabledOptionalRules = optionalRules.filter(
+		({ name }) => name in rulesConfig && Boolean(rulesConfig[name])
+	);
+
+	return [...loadedCustomRules, ...enabledOptionalRules, ...rules].filter(
+		({ name }) => !(name in rulesConfig) || rulesConfig[name] !== false
+	);
 };

src/module.ts

@@ -35,7 +35,7 @@ export default (moduleConfig: Partial<Config>) => {
 
 	if (!moduleConfig.packageScripts && moduleConfig.packageFile) {
 		const { readPackageScripts } = userPackageScriptContext(
-			makePackageFilePath(config.packageFile ?? "")
+			makePackageFilePath(config.packageFile)
 		);
 
 		scripts = readPackageScripts(config.ignoreScripts);

src/rules/index.ts

@@ -6,6 +6,7 @@ import noAliases from "./no-aliases";
 import prePostTriggerDefined from "./prepost-trigger-defined";
 import usesAllowedNamespace from "./uses-allowed-namespace";
 import alphabeticOrder from "./alphabetic-order";
+import naturalOrder from "./natural-order";
 import { Rule } from "../types";
 
 const rules: Array<Rule> = [
@@ -18,6 +19,7 @@ const rules: Array<Rule> = [
 	usesAllowedNamespace,
 	prePostTriggerDefined,
 	alphabeticOrder,
+	naturalOrder,
 	makeForbidUnixOperators(/rm /, "rm -rf", "rimraf"),
 	makeForbidUnixOperators(
 		/ && /,

src/rules/natural-order.ts

@@ -0,0 +1,84 @@
+import { PackageScripts } from "../types";
+import { objectFromEntries } from "../utils";
+
+type EntryInfo = {
+	order: number;
+	namespace: string;
+	entry: [string, string];
+};
+
+const prepareEntryInfo = (entry: [string, string]) => {
+	const name = entry[0];
+	const namespace = name.split(":")[0];
+
+	if (name.startsWith("pre")) {
+		return {
+			order: 0,
+			namespace: namespace.substr(3),
+			entry,
+		};
+	}
+	if (name.startsWith("post")) {
+		return {
+			order: 2,
+			namespace: namespace.substr(4),
+			entry,
+		};
+	}
+
+	return {
+		order: 1,
+		namespace,
+		entry,
+	};
+};
+
+export const sortScripts = (scripts: PackageScripts): PackageScripts => {
+	// prepare namespace and order info
+	const entries = Object.entries(scripts).map(prepareEntryInfo);
+
+	return objectFromEntries(
+		entries
+			// make unique namespace groups
+			.map((e: EntryInfo) => e.namespace)
+			.filter(
+				(name: string, i: number, a: Array<string>) =>
+					a.indexOf(name) === i
+			)
+			.sort()
+			.map((name: string) =>
+				entries.filter((e: EntryInfo) => e.namespace === name)
+			)
+			// sort inside the group
+			.map((group: Array<EntryInfo>) =>
+				// sort `1-title` vs `2-title` etc.
+				group.sort((a: EntryInfo, b: EntryInfo) =>
+					`${a.order}-${a.entry[0]}`.localeCompare(
+						`${b.order}-${b.entry[0]}`
+					)
+				)
+			)
+			// flatten array
+			.reduce(
+				(flatted: Array<EntryInfo>, group: Array<EntryInfo>) => [
+					...flatted,
+					...group,
+				],
+				[]
+			)
+			// reduce to entries again
+			.map((f: EntryInfo) => f.entry)
+	);
+};
+
+export default {
+	name: "natural-order",
+	isObjectRule: true,
+	message: "scripts must be in 'natural' order",
+	validate: (scripts: PackageScripts) => {
+		const sorted = sortScripts(scripts);
+
+		return Object.keys(sorted).join("|") === Object.keys(scripts).join("|");
+	},
+	fix: (scripts: PackageScripts) => sortScripts(scripts),
+};

src/types.ts

@@ -17,7 +17,7 @@ export type PackageScripts = {
 
 export type Config = {
 	strict: boolean;
-	packageFile?: string;
+	packageFile: string;
 	packageScripts?: PackageScripts;
 	fix: boolean;
 	json: boolean;

src/utils.ts

@@ -74,3 +74,10 @@ export const patchScriptObjectEntry = (
 			return k === fromKey ? [toKey, value] : [k, v];
 		})
 	);
+
+type ObjectFromEntries = {[key: string]: any};
+export const objectFromEntries = <T>(iterable: Array<[string, T]>): ObjectFromEntries => iterable.reduce((obj, [key, value]) => {
+	obj[key] = value;
+
+	return obj
+}, {} as ObjectFromEntries)

tests/cliConfig.test.ts

@@ -51,7 +51,7 @@ describe("cliConfig.ts", () => {
 			"-f",
 		]);
 
-		expect(packageFile).not.toBeDefined();
+		expect(packageFile).toEqual(process.cwd());
 
 		expect(config).toEqual({
 			fix: true,

tests/loadRules.test.ts

@@ -1,5 +1,6 @@
 import { loadRulesFromRuleConfig, getRuleByName } from "../src/loadRules";
 import defaultRules from "../src/rules";
+import {optionalRules} from "../src/defaultRuleSets";
 
 describe("loadRules.ts", () => {
 	const defaultRulesLoaded = loadRulesFromRuleConfig(false);
@@ -28,8 +29,19 @@ describe("loadRules.ts", () => {
 		).toBe(customRule.name);
 	});
 
+	it("loads optional rules", () => {
+		const rulesWithCustomRule = loadRulesFromRuleConfig(
+			false,
+			{
+				"natural-order": true,
+			}
+		);
+
+		expect(rulesWithCustomRule.map(r => r.name)[0]).toBe("natural-order");
+	});
+
 	it("loads correct amount of rules", () => {
-		expect(strictRulesLoaded.length).toBe(defaultRules.length);
+		expect(strictRulesLoaded.length).toBe(defaultRules.length - optionalRules.length);
 	});
 
 	test("getRuleByName() nulls on unknown name", () => {