@cparra/apexdocs 2.24.0 → 2.25.0-alpha.0

package/src/transpiler/markdown/plain-markdown/plain-docsProcessor.ts

@@ -1,7 +1,36 @@
 import { MarkdownTranspilerBase } from '../markdown-transpiler-base';
 import { LinkingStrategy } from '../../processor-type-transpiler';
+import { ClassMirror, EnumMirror, InterfaceMirror, Type } from '@cparra/apex-reflection';
+import { OutputFile } from '../../../model/outputFile';
+import { Settings } from '../../../settings';
+import ClassFileGeneratorHelper from '../class-file-generatorHelper';
+import { enumMarkdownTemplate } from './enum-template';
+import { compile } from '../../../templating/compile';
+import { ClassSource, EnumSource, InterfaceSource, Link, RenderableContent } from '../../../templating/types';
+import { interfaceMarkdownTemplate } from './interface-template';
+import { classMarkdownTemplate } from './class-template';
+import { isEmptyLine } from '../../../adapters/type-utils';
+import {
+  classTypeToClassSource,
+  enumTypeToEnumSource,
+  interfaceTypeToInterfaceSource,
+} from '../../../adapters/apex-types';
+import { MarkdownHomeFile } from '../../../model/markdown-home-file';
+import { MarkdownFile } from '../../../model/markdown-file';
+import Handlebars from 'handlebars';
+import fs from 'fs';
+import path from 'path';
 
 export class PlainMarkdownDocsProcessor extends MarkdownTranspilerBase {
+  _fileContents: string[] = [];
+  onBeforeProcess = (types: Type[]) => {
+    if (Settings.getInstance().shouldOutputSingleFile()) {
+      return;
+    } else {
+      this._fileContainer.pushFile(new MarkdownHomeFile(this.homeFileName(), types));
+    }
+  };
+
   homeFileName(): string {
     return 'index';
   }
@@ -9,4 +38,97 @@ export class PlainMarkdownDocsProcessor extends MarkdownTranspilerBase {
   getLinkingStrategy(): LinkingStrategy {
     return 'path-relative';
   }
+
+  onProcess(type: Type): void {
+    if (Settings.getInstance().shouldOutputSingleFile()) {
+      this._fileContents.push(this._generateOutputFile(type).body);
+    } else {
+      this._fileContainer.pushFile(this._generateOutputFile(type));
+    }
+  }
+
+  onAfterProcess: (types: Type[]) => void = () => {
+    if (Settings.getInstance().shouldOutputSingleFile()) {
+      const file = new MarkdownFile(Settings.getInstance().getSingleFileName(), '');
+
+      let contents;
+      if (Settings.getInstance().getTemplateFilePath()) {
+        const filePath = path.resolve(Settings.getInstance().getTemplateFilePath()!);
+        const templateFileContents = fs.readFileSync(filePath, {
+          encoding: 'utf-8',
+        });
+        const handlebars = Handlebars.compile(templateFileContents);
+        contents = handlebars({ api_docs: this._fileContents.join('\n\n---\n\n') });
+      } else {
+        contents = this._fileContents.join('\n\n---\n\n');
+      }
+      file.addText(contents);
+      this._fileContainer.pushFile(file);
+    }
+  };
+
+  _generateOutputFile(type: Type): OutputFile {
+    if (type.type_name === 'enum') {
+      return new GenericFile<EnumMirror>(type as EnumMirror, enumTypeToEnumSource, enumMarkdownTemplate);
+    } else if (type.type_name === 'interface') {
+      return new GenericFile<InterfaceMirror>(
+        type as InterfaceMirror,
+        interfaceTypeToInterfaceSource,
+        interfaceMarkdownTemplate,
+      );
+    } else {
+      return new GenericFile<ClassMirror>(type as ClassMirror, classTypeToClassSource, classMarkdownTemplate);
+    }
+  }
+}
+
+class GenericFile<T extends Type> extends OutputFile {
+  constructor(private type: T, toSource: (type: T) => EnumSource | InterfaceSource | ClassSource, template: string) {
+    super(
+      `${Settings.getInstance().getNamespacePrefix()}${type.name}`,
+      ClassFileGeneratorHelper.getSanitizedGroup(type),
+    );
+
+    const source = toSource(type);
+    this.addText(
+      compile(template, source, {
+        renderableContentConverter: prepareDescription,
+        codeBlockConverter: convertCodeBlock,
+      }),
+    );
+  }
+
+  fileExtension(): string {
+    return '.md';
+  }
+}
+
+function prepareDescription(description?: RenderableContent[]) {
+  if (!description) {
+    return '';
+  }
+
+  function reduceDescription(acc: string, curr: RenderableContent) {
+    if (typeof curr === 'string') {
+      return acc + curr.trim() + ' ';
+    } else if (isEmptyLine(curr)) {
+      return acc + '\n\n';
+    } else {
+      return acc + linkToMarkdown(curr) + ' ';
+    }
+  }
+
+  function linkToMarkdown(link: Link) {
+    return `[${link.title}](${link.url})`;
+  }
+
+  return description.reduce(reduceDescription, '').trim();
+}
+
+function convertCodeBlock(language: string, lines: string[]): string {
+  return `
+\`\`\`${language}
+${lines.join('\n')}
+\`\`\`
+  `.trim();
 }

package/src/transpiler/markdown/plain-markdown/type-level-apex-doc-partial-template.ts

@@ -0,0 +1,27 @@
+export const typeLevelApexDocPartialTemplate = `
+{{#> documentablePartialTemplate}}
+
+{{#if group}}
+**Group** {{group}}
+{{/if}}
+
+{{#if author}}
+**Author** {{author}}
+{{/if}}
+
+{{#if date}}
+**Date** {{date}}
+{{/if}}
+
+{{#each sees}}
+**See** {{this}}
+
+{{/each}}
+
+{{#if namespace}}
+## Namespace
+{{namespace}}
+{{/if}}
+
+{{/documentablePartialTemplate}}
+`.trim();

package/src/transpiler/openapi/parsers/Builder.ts

@@ -29,7 +29,7 @@ export abstract class Builder<T, K> {
     return schemaAware.schema;
   }
 
-  private isReferenceString = (targetObject: any): targetObject is string => {
+  private isReferenceString = (targetObject: unknown): targetObject is string => {
     return typeof targetObject === 'string' || targetObject instanceof String;
   };
 }

package/src/transpiler/openapi/parsers/MethodParser.ts

@@ -95,7 +95,7 @@ export class MethodParser {
 
     for (const annotation of annotations) {
       // We expect the ApexDoc data representing this to be in YAML format.
-      const inYaml = annotation?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
+      const inYaml = annotation?.bodyLines.reduce((prev, current) => prev + '\n' + current);
 
       if (!inYaml) {
         return;

package/src/transpiler/openapi/parsers/ReferenceBuilder.ts

@@ -131,7 +131,7 @@ export class ReferenceBuilder {
     referencedComponents: ReferenceComponent[],
   ) {
     // This can be of type ApexDocSchemaObject
-    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
+    const inYaml = manuallyDefinedHttpSchema?.bodyLines.reduce((prev, current) => prev + '\n' + current);
     const asJson = yaml.load(inYaml) as ApexDocSchemaObject;
     const isReferenceString = this.isReferenceString(asJson);
 

package/src/util/error-logger.ts

@@ -8,7 +8,7 @@ export default class ErrorLogger {
     });
   }
 
-  private static logErrorsForSingleType(currentType: Type, parentType?: Type): void {
+  private static logErrorsForSingleType(currentType: Type): void {
     this.logTypeErrors(currentType);
 
     if (currentType.type_name === 'class') {
@@ -67,15 +67,15 @@ export default class ErrorLogger {
     });
 
     classMirror.enums.forEach((currentEnum) => {
-      this.logErrorsForSingleType(currentEnum, classMirror);
+      this.logErrorsForSingleType(currentEnum);
     });
 
     classMirror.interfaces.forEach((currentInterface) => {
-      this.logErrorsForSingleType(currentInterface, classMirror);
+      this.logErrorsForSingleType(currentInterface);
     });
 
     classMirror.classes.forEach((currentClass) => {
-      this.logErrorsForSingleType(currentClass, classMirror);
+      this.logErrorsForSingleType(currentClass);
     });
   }
 

package/src/util/logger.ts

@@ -1,5 +1,5 @@
-import * as chalk from 'chalk';
-import * as logUpdate from 'log-update';
+import chalk from 'chalk';
+import logUpdate from 'log-update';
 
 /**
  * Logs messages to the console.
@@ -28,7 +28,7 @@ export class Logger {
    */
   public static error(message: string, ...args: string[]) {
     this.logSingle(message, false, 'red', false);
-    args.forEach((arg) => {
+    args.forEach(() => {
       this.logSingle(message, false, 'red', false);
     });
   }

package/tsconfig.json

@@ -1,20 +1,21 @@
-{
-  "compilerOptions": {
-    "target": "es6",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./lib",
-    "strict": true,
-    "sourceMap": true,
-    "lib": [
-      "ES2021"
-    ]
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "node_modules",
-    "**/__tests__/*"
-  ]
-}
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./lib",
+    "strict": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "lib": [
+      "ES2021"
+    ]
+  },
+  "include": [
+    "src"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/__tests__/*"
+  ]
+}

package/tslint.json

@@ -1,6 +1,6 @@
-{
-    "extends": [
-        "tslint:recommended",
-        "tslint-config-prettier"
-    ]
+{
+    "extends": [
+        "tslint:recommended",
+        "tslint-config-prettier"
+    ]
 }

package/lib/model/manifest-diff.d.ts

@@ -1,27 +0,0 @@
-import Manifest from './manifest';
-import { Type } from '@cparra/apex-reflection';
-import { Annotation } from '@cparra/apex-reflection/index';
-export declare class ManifestDiff {
-    added: Type[];
-    deleted: Type[];
-    changes: DiffChange[];
-    static build(originalManifest: Manifest, newManifest: Manifest): ManifestDiff;
-}
-declare class DiffChange {
-    originalType: Type;
-    newType: Type;
-    accessModifierChange?: AccessModifierChange;
-    annotationChanges: AnnotationChange[];
-    constructor(originalType: Type, newType: Type);
-    hasChanges(): boolean;
-    private parse;
-}
-interface AccessModifierChange {
-    oldAccessModifier: string;
-    newAccessModifier: string;
-}
-interface AnnotationChange {
-    annotation: Annotation;
-    type: 'added' | 'removed';
-}
-export {};

package/lib/model/manifest-diff.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManifestDiff = void 0;
-class ManifestDiff {
-    constructor() {
-        this.added = [];
-        this.deleted = [];
-        this.changes = [];
-    }
-    static build(originalManifest, newManifest) {
-        const addedTypes = newManifest.types.filter((currentType) => !originalManifest.types.find((originalType) => currentType.name === originalType.name));
-        const deletedTypes = originalManifest.types.filter((currentType) => !newManifest.types.find((newType) => currentType.name === newType.name));
-        const changes = [];
-        for (const newType of newManifest.types) {
-            const oldType = originalManifest.types.find((oldType) => oldType.name === newType.name);
-            if (!oldType) {
-                continue;
-            }
-            const change = new DiffChange(oldType, newType);
-            if (change.hasChanges()) {
-                changes.push(change);
-            }
-        }
-        const diff = new ManifestDiff();
-        diff.added = addedTypes;
-        diff.deleted = deletedTypes;
-        diff.changes = changes;
-        return diff;
-    }
-}
-exports.ManifestDiff = ManifestDiff;
-class DiffChange {
-    constructor(originalType, newType) {
-        this.originalType = originalType;
-        this.newType = newType;
-        this.annotationChanges = [];
-        this.parse();
-    }
-    hasChanges() {
-        return !!this.accessModifierChange || this.annotationChanges.length > 0;
-    }
-    parse() {
-        // Access modifier changes
-        if (this.originalType.access_modifier !== this.newType.access_modifier) {
-            this.accessModifierChange = {
-                oldAccessModifier: this.originalType.access_modifier,
-                newAccessModifier: this.newType.access_modifier,
-            };
-        }
-        // Annotation changes
-        const addedAnnotations = this.newType.annotations.filter((currentAnnotation) => !this.originalType.annotations.find((originalAnnotation) => currentAnnotation.name === originalAnnotation.name));
-        const removedAnnotations = this.originalType.annotations.filter((currentAnnotation) => !this.newType.annotations.find((newAnnotation) => currentAnnotation.name === newAnnotation.name));
-        const annotationChangeMapper = (annotation, changeType) => {
-            return {
-                annotation: annotation,
-                type: changeType,
-            };
-        };
-        this.annotationChanges = [
-            ...addedAnnotations.map((annotation) => {
-                return annotationChangeMapper(annotation, 'added');
-            }),
-            ...removedAnnotations.map((annotation) => {
-                return annotationChangeMapper(annotation, 'removed');
-            }),
-        ];
-    }
-}
-//# sourceMappingURL=manifest-diff.js.map

package/lib/model/manifest-diff.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest-diff.js","sourceRoot":"","sources":["../../src/model/manifest-diff.ts"],"names":[],"mappings":"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"}

package/src/model/__tests__/manifest-diff.spec.ts

@@ -1,139 +0,0 @@
-import Manifest from '../manifest';
-import { EnumMirror } from '@cparra/apex-reflection';
-import { ManifestDiff } from '../manifest-diff';
-import { Annotation } from '@cparra/apex-reflection/index';
-
-const deprecatedAnnotation: Annotation = {
-  rawDeclaration: '@deprecated',
-  name: 'deprecated',
-  type: 'deprecated',
-};
-
-const namespaceAccessibleAnnotation: Annotation = {
-  rawDeclaration: '@NamespaceAccessible',
-  name: 'namespaceaccessible',
-  type: 'namespaceaccessible',
-};
-
-it('detects when new types are added', () => {
-  const commonType = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const originalManifest = new Manifest([commonType]);
-
-  const addedType = {
-    annotations: [],
-    name: 'NewEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-  const newManifest = new Manifest([addedType, commonType]);
-
-  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
-  expect(manifestDiff.added.length).toBe(1);
-  expect(manifestDiff.added[0].name).toBe('NewEnum');
-});
-
-it('detects when types are deleted', () => {
-  const commonType = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const deletedType = {
-    annotations: [],
-    name: 'OldEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-  const originalManifest = new Manifest([commonType, deletedType]);
-  const newManifest = new Manifest([commonType]);
-
-  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
-  expect(manifestDiff.deleted.length).toBe(1);
-  expect(manifestDiff.deleted[0].name).toBe('OldEnum');
-});
-
-it('does not add enums that have no changes', () => {
-  const originalEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const modifiedEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const originalManifest = new Manifest([originalEnum]);
-  const newManifest = new Manifest([modifiedEnum]);
-
-  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
-  expect(manifestDiff.changes.length).toBe(0);
-});
-
-it('detects changes to access modifiers within an enum', () => {
-  const originalEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const modifiedEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'private',
-  } as EnumMirror;
-
-  const originalManifest = new Manifest([originalEnum]);
-  const newManifest = new Manifest([modifiedEnum]);
-
-  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
-  expect(manifestDiff.changes.length).toBe(1);
-  expect(manifestDiff.changes[0].originalType).toBe(originalEnum);
-  expect(manifestDiff.changes[0].newType).toBe(modifiedEnum);
-  expect(manifestDiff.changes[0].accessModifierChange).not.toBeNull();
-  expect(manifestDiff.changes[0].accessModifierChange?.oldAccessModifier).toBe('public');
-  expect(manifestDiff.changes[0].accessModifierChange?.newAccessModifier).toBe('private');
-});
-
-it('detects changes to annotations within an enum', () => {
-  const originalEnum = {
-    annotations: [deprecatedAnnotation],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-  } as EnumMirror;
-
-  const modifiedEnum = {
-    annotations: [namespaceAccessibleAnnotation],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'private',
-  } as EnumMirror;
-
-  const originalManifest = new Manifest([originalEnum]);
-  const newManifest = new Manifest([modifiedEnum]);
-
-  const manifestDiff = ManifestDiff.build(originalManifest, newManifest);
-  expect(manifestDiff.changes.length).toBe(1);
-  expect(manifestDiff.changes[0].annotationChanges.length).toBe(2);
-  expect(manifestDiff.changes[0].annotationChanges.find((change) => change.type === 'added')?.annotation.name).toBe(
-    namespaceAccessibleAnnotation.name,
-  );
-  expect(manifestDiff.changes[0].annotationChanges.find((change) => change.type === 'removed')?.annotation.name).toBe(
-    deprecatedAnnotation.name,
-  );
-});

package/src/model/manifest-diff.ts

@@ -1,94 +0,0 @@
-import Manifest from './manifest';
-import { Type } from '@cparra/apex-reflection';
-import { Annotation } from '@cparra/apex-reflection/index';
-
-export class ManifestDiff {
-  added: Type[] = [];
-  deleted: Type[] = [];
-  changes: DiffChange[] = [];
-
-  static build(originalManifest: Manifest, newManifest: Manifest) {
-    const addedTypes = newManifest.types.filter(
-      (currentType) => !originalManifest.types.find((originalType) => currentType.name === originalType.name),
-    );
-    const deletedTypes = originalManifest.types.filter(
-      (currentType) => !newManifest.types.find((newType) => currentType.name === newType.name),
-    );
-
-    const changes: DiffChange[] = [];
-    for (const newType of newManifest.types) {
-      const oldType = originalManifest.types.find((oldType) => oldType.name === newType.name);
-      if (!oldType) {
-        continue;
-      }
-
-      const change = new DiffChange(oldType, newType);
-      if (change.hasChanges()) {
-        changes.push(change);
-      }
-    }
-
-    const diff = new ManifestDiff();
-    diff.added = addedTypes;
-    diff.deleted = deletedTypes;
-    diff.changes = changes;
-    return diff;
-  }
-}
-
-class DiffChange {
-  accessModifierChange?: AccessModifierChange;
-  annotationChanges: AnnotationChange[] = [];
-
-  constructor(public originalType: Type, public newType: Type) {
-    this.parse();
-  }
-
-  public hasChanges(): boolean {
-    return !!this.accessModifierChange || this.annotationChanges.length > 0;
-  }
-
-  private parse() {
-    // Access modifier changes
-    if (this.originalType.access_modifier !== this.newType.access_modifier) {
-      this.accessModifierChange = {
-        oldAccessModifier: this.originalType.access_modifier,
-        newAccessModifier: this.newType.access_modifier,
-      };
-    }
-
-    // Annotation changes
-    const addedAnnotations = this.newType.annotations.filter(
-      (currentAnnotation) =>
-        !this.originalType.annotations.find((originalAnnotation) => currentAnnotation.name === originalAnnotation.name),
-    );
-    const removedAnnotations = this.originalType.annotations.filter(
-      (currentAnnotation) =>
-        !this.newType.annotations.find((newAnnotation) => currentAnnotation.name === newAnnotation.name),
-    );
-    const annotationChangeMapper = (annotation: Annotation, changeType: 'added' | 'removed') => {
-      return {
-        annotation: annotation,
-        type: changeType,
-      } as AnnotationChange;
-    };
-    this.annotationChanges = [
-      ...addedAnnotations.map((annotation) => {
-        return annotationChangeMapper(annotation, 'added');
-      }),
-      ...removedAnnotations.map((annotation) => {
-        return annotationChangeMapper(annotation, 'removed');
-      }),
-    ];
-  }
-}
-
-interface AccessModifierChange {
-  oldAccessModifier: string;
-  newAccessModifier: string;
-}
-
-interface AnnotationChange {
-  annotation: Annotation;
-  type: 'added' | 'removed';
-}