Added an overloads option in completed-docs (#4563)

src/rules/completed-docs/exclusions.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright 2013 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { hasOwnProperty } from "../../utils";
+import { DESCRIPTOR_OVERLOADS, 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, DocTypeExclusions>;
+
+export interface DocTypeExclusions {
+    overloadsSeparateDocs?: boolean;
+    requirements: Array<Exclusion<any>>;
+}
+
+export const constructExclusionsMap = (
+    ruleArguments: IInputExclusionDescriptors[],
+): ExclusionsMap => {
+    const exclusions: ExclusionsMap = new Map();
+
+    for (const ruleArgument of ruleArguments) {
+        addRequirements(exclusions, ruleArgument);
+    }
+
+    return exclusions;
+};
+
+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]),
+            );
+        }
+    }
+};
+
+const createRequirementsForDocType = (docType: DocType, descriptor: InputExclusionDescriptor) => {
+    const requirements = [];
+    let overloadsSeparateDocs = false;
+
+    if (typeof descriptor === "object" && DESCRIPTOR_OVERLOADS in descriptor) {
+        overloadsSeparateDocs = !!(descriptor as any)[DESCRIPTOR_OVERLOADS];
+    }
+
+    if (docType === "methods" || docType === "properties") {
+        requirements.push(new ClassExclusion(descriptor as IClassExclusionDescriptor));
+    } else {
+        requirements.push(new BlockExclusion(descriptor as IBlockExclusionDescriptor));
+    }
+
+    if ((descriptor as ITagExclusionDescriptor).tags !== undefined) {
+        requirements.push(new TagExclusion(descriptor as ITagExclusionDescriptor));
+    }
+
+    return {
+        overloadsSeparateDocs,
+        requirements,
+    };
+};