Added an overloads option in completed-docs

src/rules/completed-docs/exclusionFactory.ts

@@ -16,56 +16,69 @@
  */
 
 import { hasOwnProperty } from "../../utils";
-import { DocType } from "../completedDocsRule";
+import { DESCRIPTOR_OVERLOADS_SEPARATE_DOCS, DocType } from "../completedDocsRule";
 
 import { BlockExclusion, IBlockExclusionDescriptor } from "./blockExclusion";
 import { ClassExclusion, IClassExclusionDescriptor } from "./classExclusion";
 import { Exclusion } from "./exclusion";
 import { IInputExclusionDescriptors, InputExclusionDescriptor } from "./exclusionDescriptors";
 import { ITagExclusionDescriptor, TagExclusion } from "./tagExclusion";
 
-export type ExclusionsMap = Map<DocType, Array<Exclusion<any>>>;
+export type ExclusionsMap = Map<DocType, DocTypeExclusions>;
 
-export class ExclusionFactory {
-    public constructExclusionsMap(ruleArguments: IInputExclusionDescriptors[]): ExclusionsMap {
-        const exclusionsMap: ExclusionsMap = new Map();
+export interface DocTypeExclusions {
+    overloadsSeparateDocs?: boolean;
+    requirements: Array<Exclusion<any>>;
+}
 
-        for (const ruleArgument of ruleArguments) {
-            this.addRequirements(exclusionsMap, ruleArgument);
-        }
+export const constructExclusionsMap = (
+    ruleArguments: IInputExclusionDescriptors[],
+): ExclusionsMap => {
+    const exclusions: ExclusionsMap = new Map();
 
-        return exclusionsMap;
+    for (const ruleArgument of ruleArguments) {
+        addRequirements(exclusions, ruleArgument);
     }
 
-    private addRequirements(exclusionsMap: ExclusionsMap, descriptors: IInputExclusionDescriptors) {
-        if (typeof descriptors === "string") {
-            exclusionsMap.set(descriptors, this.createRequirementsForDocType(descriptors, {}));
-            return;
-        }
+    return exclusions;
+};
 
-        for (const docType in descriptors) {
-            if (hasOwnProperty(descriptors, docType)) {
-                exclusionsMap.set(
-                    docType as DocType,
-                    this.createRequirementsForDocType(docType as DocType, descriptors[docType]),
-                );
-            }
+const addRequirements = (exclusionsMap: ExclusionsMap, descriptors: IInputExclusionDescriptors) => {
+    if (typeof descriptors === "string") {
+        exclusionsMap.set(descriptors, createRequirementsForDocType(descriptors, {}));
+        return;
+    }
+
+    for (const docType in descriptors) {
+        if (hasOwnProperty(descriptors, docType)) {
+            exclusionsMap.set(
+                docType as DocType,
+                createRequirementsForDocType(docType as DocType, descriptors[docType]),
+            );
         }
     }
+};
 
-    private createRequirementsForDocType(docType: DocType, descriptor: InputExclusionDescriptor) {
-        const requirements = [];
+const createRequirementsForDocType = (docType: DocType, descriptor: InputExclusionDescriptor) => {
+    const requirements = [];
+    let overloadsSeparateDocs = false;
 
-        if (docType === "methods" || docType === "properties") {
-            requirements.push(new ClassExclusion(descriptor as IClassExclusionDescriptor));
-        } else {
-            requirements.push(new BlockExclusion(descriptor as IBlockExclusionDescriptor));
-        }
+    if (typeof descriptor === "object" && DESCRIPTOR_OVERLOADS_SEPARATE_DOCS in descriptor) {
+        overloadsSeparateDocs = !!(descriptor as any)[DESCRIPTOR_OVERLOADS_SEPARATE_DOCS];
+    }
 
-        if ((descriptor as ITagExclusionDescriptor).tags !== undefined) {
-            requirements.push(new TagExclusion(descriptor as ITagExclusionDescriptor));
-        }
+    if (docType === "methods" || docType === "properties") {
+        requirements.push(new ClassExclusion(descriptor as IClassExclusionDescriptor));
+    } else {
+        requirements.push(new BlockExclusion(descriptor as IBlockExclusionDescriptor));
+    }
 
-        return requirements;
+    if ((descriptor as ITagExclusionDescriptor).tags !== undefined) {
+        requirements.push(new TagExclusion(descriptor as ITagExclusionDescriptor));
     }
-}
+
+    return {
+        overloadsSeparateDocs,
+        requirements,
+    };
+};