refactor: #181 Rename DocumentationableNode to JSDocableNode.

BREAKING CHANGE: getDocs(), insertDoc(), etc. have been renamed to getJsDocs(), insertJsDoc(), etc...

code-generation/createGetStructureFunctions.ts

@@ -59,7 +59,7 @@ function shouldAllowExtends(structure: InterfaceViewModel, extendsStructure: Int
         switch (extendsStructure.name) {
             case "ParameteredNodeStructure":
             case "TypeParameteredNodeStructure":
-            case "DocumentationableNodeStructure":
+            case "JSDocableNodeStructure":
             case "SignaturedDeclarationStructure":
             case "ReturnTypedNodeStructure":
             case "GeneratorableNodeStructure":
@@ -73,7 +73,7 @@ function shouldAllowExtends(structure: InterfaceViewModel, extendsStructure: Int
         switch (extendsStructure.name) {
             case "ParameteredNodeStructure":
             case "TypeParameteredNodeStructure":
-            case "DocumentationableNodeStructure":
+            case "JSDocableNodeStructure":
             case "SignaturedDeclarationStructure":
             case "ReturnTypedNodeStructure":
             case "GeneratorableNodeStructure":
@@ -88,7 +88,7 @@ function shouldAllowExtends(structure: InterfaceViewModel, extendsStructure: Int
         switch (extendsStructure.name) {
             case "ParameteredNodeStructure":
             case "TypeParameteredNodeStructure":
-            case "DocumentationableNodeStructure":
+            case "JSDocableNodeStructure":
             case "SignaturedDeclarationStructure":
             case "ReturnTypedNodeStructure":
                 return false;

docs/details/documentation.md

@@ -16,22 +16,22 @@ function getName(person: Person) {
 }
 ```
 
-### Get all documentation nodes
+### Get all JS doc nodes
 
-Get all the documentation nodes by using `getDocNodes()`:
+Get all the JS doc nodes by using `getJsDocs()`:
 
 ```typescript
-functionDeclaration.getDocNodes(); // returns: JSDoc[]
+functionDeclaration.getJsDocs(); // returns: JSDoc[]
 ```
 
 ### Add/insert docs
 
-Add or insert documentation comments using the `addDoc()`, `addDocs()`, `insertDoc()`, and `insertDocs()` methods.
+Add or insert JS doc comments using the `addJsDoc()`, `addJsDocs()`, `insertJsDoc()`, and `insertJsDocs()` methods.
 
 For example:
 
 ```typescript
-const docNode = classDeclaration.addDoc({
+const docNode = classDeclaration.addJsDoc({
     description: "Some description..."
 });
 ```
@@ -44,8 +44,8 @@ Get the comment:
 
 ```typescript
 // getting the node from the original example above
-const jsDocNode = functionDeclaration.getDocNodes()[0];
-jsDocNode.getComment(); // returns string: "Gets the name."
+const jsDoc = functionDeclaration.getJsDocs()[0];
+jsDoc.getComment(); // returns string: "Gets the name."
 ```
 
 Get the tags:

src/compiler/base/DocumentationableNode.ts → src/compiler/base/JSDocableNode.ts

@@ -1,70 +1,70 @@
 import * as ts from "typescript";
 import {Constructor} from "./../../Constructor";
 import {insertIntoParent, verifyAndGetIndex, getEndIndexFromArray} from "./../../manipulation";
-import {JSDocStructure, DocumentationableNodeStructure} from "./../../structures";
+import {JSDocStructure, JSDocableNodeStructure} from "./../../structures";
 import {callBaseFill} from "./../callBaseFill";
 import {ArrayUtils} from "./../../utils";
 import {Node} from "./../common";
 import {JSDoc} from "./../doc/JSDoc";
 
-export type DocumentationableNodeExtensionType = Node<any>;
+export type JSDocableNodeExtensionType = Node<any>;
 
-export interface DocumentationableNode {
+export interface JSDocableNode {
     /**
-     * Gets the documentation nodes.
+     * Gets the JS doc nodes.
      */
-    getDocNodes(): JSDoc[];
+    getJsDocs(): JSDoc[];
     /**
-     * Adds a documentation comment.
+     * Adds a JS doc.
      * @param structure - Structure to add.
      */
-    addDoc(structure: JSDocStructure): JSDoc;
+    addJsDoc(structure: JSDocStructure): JSDoc;
     /**
-     * Adds documentation comments.
+     * Adds JS docs.
      * @param structures - Structures to add.
      */
-    addDocs(structures: JSDocStructure[]): JSDoc[];
+    addJsDocs(structures: JSDocStructure[]): JSDoc[];
     /**
-     * Inserts a documentation comment.
+     * Inserts a JS doc.
      * @param index - Index to insert at.
      * @param structure - Structure to insert.
      */
-    insertDoc(index: number, structure: JSDocStructure): JSDoc;
+    insertJsDoc(index: number, structure: JSDocStructure): JSDoc;
     /**
-     * Inserts documentation comments.
+     * Inserts JS docs.
      * @param index - Index to insert at.
      * @param structures - Structures to insert.
      */
-    insertDocs(index: number, structures: JSDocStructure[]): JSDoc[];
+    insertJsDocs(index: number, structures: JSDocStructure[]): JSDoc[];
 }
 
-export function DocumentationableNode<T extends Constructor<DocumentationableNodeExtensionType>>(Base: T): Constructor<DocumentationableNode> & T {
-    return class extends Base implements DocumentationableNode {
-        getDocNodes(): JSDoc[] {
+export function JSDocableNode<T extends Constructor<JSDocableNodeExtensionType>>(Base: T): Constructor<JSDocableNode> & T {
+    return class extends Base implements JSDocableNode {
+        getJsDocs(): JSDoc[] {
             const nodes = (this.compilerNode as any).jsDoc as ts.JSDoc[] || [];
             return nodes.map(n => this.global.compilerFactory.getNodeFromCompilerNode(n, this.sourceFile) as JSDoc);
         }
 
-        addDoc(structure: JSDocStructure) {
-            return this.addDocs([structure])[0];
+        addJsDoc(structure: JSDocStructure) {
+            return this.addJsDocs([structure])[0];
         }
 
-        addDocs(structures: JSDocStructure[]) {
-            return this.insertDocs(getEndIndexFromArray((this.compilerNode as any).jsDoc), structures);
+        addJsDocs(structures: JSDocStructure[]) {
+            return this.insertJsDocs(getEndIndexFromArray((this.compilerNode as any).jsDoc), structures);
         }
 
-        insertDoc(index: number, structure: JSDocStructure) {
-            return this.insertDocs(index, [structure])[0];
+        insertJsDoc(index: number, structure: JSDocStructure) {
+            return this.insertJsDocs(index, [structure])[0];
         }
 
-        insertDocs(index: number, structures: JSDocStructure[]) {
+        insertJsDocs(index: number, structures: JSDocStructure[]) {
             if (ArrayUtils.isNullOrEmpty(structures))
                 return [];
 
             const indentationText = this.getIndentationText();
             const newLineText = this.global.manipulationSettings.getNewLineKind();
             const code = `${getDocumentationCode(structures, indentationText, newLineText)}${newLineText}${indentationText}`;
-            const nodes = this.getDocNodes();
+            const nodes = this.getJsDocs();
             index = verifyAndGetIndex(index, nodes.length);
 
             const insertPos = index === nodes.length ? this.getStart() : nodes[index].getStart();
@@ -76,14 +76,14 @@ export function DocumentationableNode<T extends Constructor<DocumentationableNod
                 insertItemsCount: structures.length
             });
 
-            return this.getDocNodes().slice(index, index + structures.length);
+            return this.getJsDocs().slice(index, index + structures.length);
         }
 
-        fill(structure: Partial<DocumentationableNodeStructure>) {
+        fill(structure: Partial<JSDocableNodeStructure>) {
             callBaseFill(Base.prototype, this, structure);
 
             if (structure.docs != null && structure.docs.length > 0)
-                this.addDocs(structure.docs);
+                this.addJsDocs(structure.docs);
 
             return this;
         }

src/compiler/base/index.ts

@@ -5,7 +5,7 @@ export * from "./BodiedNode";
 export * from "./BodyableNode";
 export * from "./ChildOrderableNode";
 export * from "./DecoratableNode";
-export * from "./DocumentationableNode";
+export * from "./JSDocableNode";
 export * from "./ExportableNode";
 export * from "./ExtendsClauseableNode";
 export * from "./GeneratorableNode";

src/compiler/class/ClassDeclaration.ts

@@ -7,7 +7,7 @@ import {PropertyDeclarationStructure, MethodDeclarationStructure, ConstructorDec
     SetAccessorDeclarationStructure, ClassDeclarationStructure} from "./../../structures";
 import * as structureToTexts from "./../../structureToTexts";
 import {Node} from "./../common";
-import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, DocumentationableNode, TypeParameteredNode, DecoratableNode, HeritageClauseableNode,
+import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, JSDocableNode, TypeParameteredNode, DecoratableNode, HeritageClauseableNode,
     ImplementsClauseableNode, TextInsertableNode, ChildOrderableNode} from "./../base";
 import {HeritageClause} from "./../general";
 import {AbstractableNode} from "./base";
@@ -29,7 +29,7 @@ export type ClassStaticMemberTypes = MethodDeclaration | ClassStaticPropertyType
 export type ClassMemberTypes = MethodDeclaration | PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | ParameterDeclaration;
 
 export const ClassDeclarationBase = ChildOrderableNode(TextInsertableNode(ImplementsClauseableNode(HeritageClauseableNode(DecoratableNode(TypeParameteredNode(
-    NamespaceChildableNode(DocumentationableNode(AmbientableNode(AbstractableNode(ExportableNode(ModifierableNode(NamedNode(Node)))))))
+    NamespaceChildableNode(JSDocableNode(AmbientableNode(AbstractableNode(ExportableNode(ModifierableNode(NamedNode(Node)))))))
 ))))));
 export class ClassDeclaration extends ClassDeclarationBase<ts.ClassDeclaration> {
     /**

src/compiler/class/PropertyDeclaration.ts

@@ -4,12 +4,12 @@ import {PropertyDeclarationStructure} from "./../../structures";
 import {removeClassMember, removeInterfaceMember} from "./../../manipulation";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {PropertyNamedNode, TypedNode, InitializerExpressionableNode, QuestionTokenableNode, ReadonlyableNode, DocumentationableNode, StaticableNode,
+import {PropertyNamedNode, TypedNode, InitializerExpressionableNode, QuestionTokenableNode, ReadonlyableNode, JSDocableNode, StaticableNode,
     ModifierableNode, ScopedNode, DecoratableNode, ChildOrderableNode} from "./../base";
 import {ClassDeclaration} from "./ClassDeclaration";
 import {AbstractableNode} from "./base";
 
-export const PropertyDeclarationBase = ChildOrderableNode(DecoratableNode(AbstractableNode(ScopedNode(StaticableNode(DocumentationableNode(
+export const PropertyDeclarationBase = ChildOrderableNode(DecoratableNode(AbstractableNode(ScopedNode(StaticableNode(JSDocableNode(
     ReadonlyableNode(QuestionTokenableNode(InitializerExpressionableNode(TypedNode(PropertyNamedNode(ModifierableNode(Node))))))
 ))))));
 export class PropertyDeclaration extends PropertyDeclarationBase<ts.PropertyDeclaration> {

src/compiler/common/Node.ts

@@ -765,8 +765,8 @@ export class Node<NodeType extends ts.Node = ts.Node> {
 
         function getNodes(node: Node) {
             const nodes: Node[] = [];
-            if (TypeGuards.isDocumentationableNode(node) && node.getDocNodes().length > 0)
-                nodes.push(...node.getDocNodes());
+            if (TypeGuards.isJSDocableNode(node) && node.getJsDocs().length > 0)
+                nodes.push(...node.getJsDocs());
             nodes.push(node);
             return nodes;
         }

src/compiler/enum/EnumDeclaration.ts

@@ -5,12 +5,12 @@ import {insertIntoCommaSeparatedNodes, verifyAndGetIndex, removeStatementedNodeC
 import {EnumMemberStructureToText} from "./../../structureToTexts";
 import {getNamedNodeByNameOrFindFunction, getNotFoundErrorMessageForNameOrFindFunction, TypeGuards} from "./../../utils";
 import {callBaseFill} from "./../callBaseFill";
-import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, DocumentationableNode, TextInsertableNode, ChildOrderableNode} from "./../base";
+import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, JSDocableNode, TextInsertableNode, ChildOrderableNode} from "./../base";
 import {Node} from "./../common";
 import {NamespaceChildableNode} from "./../namespace";
 import {EnumMember} from "./EnumMember";
 
-export const EnumDeclarationBase = ChildOrderableNode(TextInsertableNode(NamespaceChildableNode(DocumentationableNode(AmbientableNode(ExportableNode(
+export const EnumDeclarationBase = ChildOrderableNode(TextInsertableNode(NamespaceChildableNode(JSDocableNode(AmbientableNode(ExportableNode(
     ModifierableNode(NamedNode(Node))
 ))))));
 export class EnumDeclaration extends EnumDeclarationBase<ts.EnumDeclaration> {

src/compiler/enum/EnumMember.ts

@@ -3,9 +3,9 @@ import {removeChildrenWithFormatting, FormattingKind} from "./../../manipulation
 import {EnumMemberStructure} from "./../../structures";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {PropertyNamedNode, InitializerExpressionableNode, DocumentationableNode} from "./../base";
+import {PropertyNamedNode, InitializerExpressionableNode, JSDocableNode} from "./../base";
 
-export const EnumMemberBase = DocumentationableNode(InitializerExpressionableNode(PropertyNamedNode(Node)));
+export const EnumMemberBase = JSDocableNode(InitializerExpressionableNode(PropertyNamedNode(Node)));
 export class EnumMember extends EnumMemberBase<ts.EnumMember> {
     /**
      * Fills the node from a structure.

src/compiler/function/FunctionExpression.ts

@@ -1,10 +1,10 @@
 import * as ts from "typescript";
 import {Expression} from "./../common";
-import {DocumentationableNode, NameableNode, ModifierableNode, AsyncableNode, GeneratorableNode, BodiedNode, TextInsertableNode} from "./../base";
+import {JSDocableNode, NameableNode, ModifierableNode, AsyncableNode, GeneratorableNode, BodiedNode, TextInsertableNode} from "./../base";
 import {StatementedNode} from "./../statement";
 import {SignaturedDeclaration} from "./SignaturedDeclaration";
 
-export const FunctionExpressionBase = DocumentationableNode(TextInsertableNode(BodiedNode(AsyncableNode(GeneratorableNode(StatementedNode(
+export const FunctionExpressionBase = JSDocableNode(TextInsertableNode(BodiedNode(AsyncableNode(GeneratorableNode(StatementedNode(
     SignaturedDeclaration(ModifierableNode(NameableNode(Expression))
 )))))));
 export class FunctionExpression extends FunctionExpressionBase<ts.FunctionExpression> {

src/compiler/function/FunctionLikeDeclaration.ts

@@ -1,15 +1,15 @@
 import * as ts from "typescript";
 import {Constructor} from "./../../Constructor";
 import {Node} from "./../common";
-import {DocumentationableNode, ModifierableNode} from "./../base";
+import {JSDocableNode, ModifierableNode} from "./../base";
 import {StatementedNode} from "./../statement";
 import {SignaturedDeclaration} from "./SignaturedDeclaration";
 
 export type FunctionLikeDeclarationExtensionType = Node<ts.FunctionLikeDeclaration>;
 
-export interface FunctionLikeDeclaration extends DocumentationableNode, SignaturedDeclaration, StatementedNode, ModifierableNode {
+export interface FunctionLikeDeclaration extends JSDocableNode, SignaturedDeclaration, StatementedNode, ModifierableNode {
 }
 
 export function FunctionLikeDeclaration<T extends Constructor<FunctionLikeDeclarationExtensionType>>(Base: T): Constructor<FunctionLikeDeclaration> & T {
-    return DocumentationableNode(SignaturedDeclaration(StatementedNode(ModifierableNode(Base))));
+    return JSDocableNode(SignaturedDeclaration(StatementedNode(ModifierableNode(Base))));
 }

src/compiler/interface/ConstructSignatureDeclaration.ts

@@ -3,10 +3,10 @@ import {ConstructSignatureDeclarationStructure} from "./../../structures";
 import {removeInterfaceMember} from "./../../manipulation";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {DocumentationableNode, ChildOrderableNode} from "./../base";
+import {JSDocableNode, ChildOrderableNode} from "./../base";
 import {SignaturedDeclaration} from "./../function";
 
-export const ConstructSignatureDeclarationBase = ChildOrderableNode(DocumentationableNode(SignaturedDeclaration(Node)));
+export const ConstructSignatureDeclarationBase = ChildOrderableNode(JSDocableNode(SignaturedDeclaration(Node)));
 export class ConstructSignatureDeclaration extends ConstructSignatureDeclarationBase<ts.ConstructSignatureDeclaration> {
     /**
      * Fills the node from a structure.

src/compiler/interface/InterfaceDeclaration.ts

@@ -6,7 +6,7 @@ import {getNamedNodeByNameOrFindFunction, getNotFoundErrorMessageForNameOrFindFu
 import * as structureToTexts from "./../../structureToTexts";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, DocumentationableNode, TypeParameteredNode, HeritageClauseableNode,
+import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, JSDocableNode, TypeParameteredNode, HeritageClauseableNode,
     ExtendsClauseableNode, TextInsertableNode, ChildOrderableNode} from "./../base";
 import {NamespaceChildableNode} from "./../namespace";
 import {ImplementationLocation} from "./../tools";
@@ -17,7 +17,7 @@ import {PropertySignature} from "./PropertySignature";
 export type InterfaceMemberTypes = PropertySignature | MethodSignature | ConstructSignatureDeclaration;
 
 export const InterfaceDeclarationBase = ChildOrderableNode(TextInsertableNode(ExtendsClauseableNode(HeritageClauseableNode(TypeParameteredNode(
-    DocumentationableNode(AmbientableNode(NamespaceChildableNode(ExportableNode(ModifierableNode(NamedNode(Node))))))
+    JSDocableNode(AmbientableNode(NamespaceChildableNode(ExportableNode(ModifierableNode(NamedNode(Node))))))
 )))));
 export class InterfaceDeclaration extends InterfaceDeclarationBase<ts.InterfaceDeclaration> {
     /**

src/compiler/interface/MethodSignature.ts

@@ -3,10 +3,10 @@ import {MethodSignatureStructure} from "./../../structures";
 import {removeInterfaceMember} from "./../../manipulation";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {PropertyNamedNode, QuestionTokenableNode, DocumentationableNode, ChildOrderableNode} from "./../base";
+import {PropertyNamedNode, QuestionTokenableNode, JSDocableNode, ChildOrderableNode} from "./../base";
 import {SignaturedDeclaration} from "./../function";
 
-export const MethodSignatureBase = ChildOrderableNode(DocumentationableNode(QuestionTokenableNode(SignaturedDeclaration(PropertyNamedNode(Node)))));
+export const MethodSignatureBase = ChildOrderableNode(JSDocableNode(QuestionTokenableNode(SignaturedDeclaration(PropertyNamedNode(Node)))));
 export class MethodSignature extends MethodSignatureBase<ts.MethodSignature> {
     /**
      * Fills the node from a structure.

src/compiler/interface/PropertySignature.ts

@@ -3,10 +3,10 @@ import {removeInterfaceMember} from "./../../manipulation";
 import {PropertySignatureStructure} from "./../../structures";
 import {callBaseFill} from "./../callBaseFill";
 import {Node} from "./../common";
-import {PropertyNamedNode, TypedNode, InitializerExpressionableNode, QuestionTokenableNode, ReadonlyableNode, DocumentationableNode, ModifierableNode,
+import {PropertyNamedNode, TypedNode, InitializerExpressionableNode, QuestionTokenableNode, ReadonlyableNode, JSDocableNode, ModifierableNode,
     ChildOrderableNode} from "./../base";
 
-export const PropertySignatureBase = ChildOrderableNode(DocumentationableNode(ReadonlyableNode(QuestionTokenableNode(InitializerExpressionableNode(TypedNode(
+export const PropertySignatureBase = ChildOrderableNode(JSDocableNode(ReadonlyableNode(QuestionTokenableNode(InitializerExpressionableNode(TypedNode(
     PropertyNamedNode(ModifierableNode(Node))
 ))))));
 export class PropertySignature extends PropertySignatureBase<ts.PropertySignature> {

src/compiler/namespace/NamespaceDeclaration.ts

@@ -4,12 +4,12 @@ import {replaceNodeText, removeStatementedNodeChild} from "./../../manipulation"
 import {NamespaceDeclarationStructure} from "./../../structures";
 import {callBaseFill} from "./../callBaseFill";
 import {Node, Identifier} from "./../common";
-import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, DocumentationableNode, BodiedNode, TextInsertableNode, UnwrappableNode,
+import {NamedNode, ExportableNode, ModifierableNode, AmbientableNode, JSDocableNode, BodiedNode, TextInsertableNode, UnwrappableNode,
     ChildOrderableNode} from "./../base";
 import {StatementedNode} from "./../statement";
 import {NamespaceChildableNode} from "./NamespaceChildableNode";
 
-export const NamespaceDeclarationBase = ChildOrderableNode(UnwrappableNode(TextInsertableNode(BodiedNode(NamespaceChildableNode(StatementedNode(DocumentationableNode(
+export const NamespaceDeclarationBase = ChildOrderableNode(UnwrappableNode(TextInsertableNode(BodiedNode(NamespaceChildableNode(StatementedNode(JSDocableNode(
     AmbientableNode(ExportableNode(ModifierableNode(NamedNode(Node))))
 )))))));
 export class NamespaceDeclaration extends NamespaceDeclarationBase<ts.NamespaceDeclaration> {