@cparra/apexdocs 2.25.0 → 3.0.0-alpha.10

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

@@ -1,147 +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',
-    values: [],
-  } as EnumMirror;
-
-  const originalManifest = new Manifest([commonType]);
-
-  const addedType = {
-    annotations: [],
-    name: 'NewEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-    values: [],
-  } 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',
-    values: [],
-  } as EnumMirror;
-
-  const deletedType = {
-    annotations: [],
-    name: 'OldEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-    values: [],
-  } 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',
-    values: [],
-  } as EnumMirror;
-
-  const modifiedEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'public',
-    values: [],
-  } 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',
-    values: [],
-  } as EnumMirror;
-
-  const modifiedEnum = {
-    annotations: [],
-    name: 'CommonEnum',
-    type_name: 'enum',
-    access_modifier: 'private',
-    values: [],
-  } 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/apex-bundle.ts

@@ -1,3 +0,0 @@
-export default class ApexBundle {
-  constructor(public filePath: string, public rawTypeContent: string, public rawMetadataContent: string | null) {}
-}

package/src/model/inheritance.ts

@@ -1,7 +0,0 @@
-import { FieldMirror, MethodMirror, PropertyMirror } from '@cparra/apex-reflection';
-
-export type InheritanceSupport = { inherited: boolean };
-export type FieldMirrorWithInheritance = FieldMirror & InheritanceSupport;
-export type PropertyMirrorWithInheritance = PropertyMirror & InheritanceSupport;
-export type MethodMirrorWithInheritance = MethodMirror & InheritanceSupport;
-export type FieldOrProperty = FieldMirrorWithInheritance | PropertyMirrorWithInheritance;

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';
-}

package/src/model/manifest.ts

@@ -1,74 +0,0 @@
-import {
-  ClassMirror,
-  EnumMirror,
-  InterfaceMirror,
-  Type,
-  Annotation,
-  DocComment,
-  DocCommentAnnotation,
-} from '@cparra/apex-reflection';
-
-type AccessAndDocAware = { access_modifier: string; annotations: Annotation[]; docComment?: DocComment };
-
-/**
- * Represents the full library of Apex top-level types (classes, enums, and interface) for a Salesforce project.
- */
-export default class Manifest {
-  /**
-   * Constructs a new Manifest object.
-   * @param types List of types to be wrapped by this object.
-   * @param isForInnerTypes Whether this manifest represent an inner type or not.
-   */
-  constructor(public types: Type[], public isForInnerTypes: boolean = false) {}
-
-  filteredByAccessModifierAndAnnotations(modifiers: string[]): Type[] {
-    const filteredTypes = this.filterAccessibleModifier(this.types, modifiers);
-    const typesToReturn: Type[] = [];
-    for (const filteredType of filteredTypes) {
-      const currentType = filteredType as Type;
-      if (currentType.type_name !== 'class') {
-        typesToReturn.push(currentType);
-        continue;
-      }
-
-      const currentClass = currentType as ClassMirror;
-      let filteredClass = {
-        ...currentType,
-        methods: this.filterAccessibleModifier(currentClass.methods, modifiers),
-        properties: this.filterAccessibleModifier(currentClass.properties, modifiers),
-        fields: this.filterAccessibleModifier(currentClass.fields, modifiers),
-        constructors: this.filterAccessibleModifier(currentClass.constructors, modifiers),
-      };
-
-      if (!this.isForInnerTypes) {
-        filteredClass = {
-          ...filteredClass,
-          enums: this.filterAccessibleModifier(currentClass.enums, modifiers) as EnumMirror[],
-          interfaces: this.filterAccessibleModifier(currentClass.interfaces, modifiers) as InterfaceMirror[],
-          classes: new Manifest(currentClass.classes, true).filteredByAccessModifierAndAnnotations(
-            modifiers,
-          ) as ClassMirror[],
-        };
-      }
-
-      typesToReturn.push(filteredClass as ClassMirror);
-    }
-
-    return typesToReturn;
-  }
-
-  filterAccessibleModifier(accessAndDocAwares: AccessAndDocAware[], modifiers: string[]) {
-    return accessAndDocAwares.filter((currentType) => {
-      const hasIgnoreDocAnnotation = currentType.docComment?.annotations.some(
-        (annotation: DocCommentAnnotation) => annotation.name === 'ignore',
-      );
-      if (hasIgnoreDocAnnotation) {
-        return false;
-      }
-      return (
-        modifiers.includes(currentType.access_modifier) ||
-        currentType.annotations.some((annotation: Annotation) => modifiers.includes(annotation.type.toLowerCase()))
-      );
-    });
-  }
-}

package/src/model/markdown-file.ts

@@ -1,121 +0,0 @@
-import { OutputFile } from './outputFile';
-import ClassFileGeneratorHelper from '../transpiler/markdown/class-file-generatorHelper';
-
-export class MarkdownFile extends OutputFile {
-  fileExtension(): string {
-    return '.md';
-  }
-
-  addTitle(text: string, level = 1) {
-    let title = '';
-    for (let i = 0; i < level; i++) {
-      title += '#';
-    }
-
-    title += ' ';
-    title += text;
-    this._contents += title;
-    this.addBlankLine();
-  }
-
-  public addText(text: string, encodeHtml = true) {
-    super.addText(this._replaceInlineReferences(text), encodeHtml);
-  }
-
-  public addLink(text: string, encodeHtml = true) {
-    this.addText(`\{@link ${text}\}`, encodeHtml);
-  }
-
-  startCodeBlock(language = 'apex') {
-    this.addText(`\`\`\`${language}`);
-  }
-
-  endCodeBlock() {
-    this.addText('```');
-    this.addBlankLine();
-  }
-
-  addHorizontalRule() {
-    this._contents += '---';
-    this.addBlankLine();
-  }
-
-  initializeTable(...headers: string[]) {
-    this.addBlankLine();
-    this._contents += '|';
-    headers.forEach((header) => {
-      this._contents += header + '|';
-    });
-    this.addBlankLine();
-    this._contents += '|';
-    headers.forEach((_) => {
-      this._contents += '---' + '|';
-    });
-    this.addBlankLine();
-  }
-
-  addTableRow(...columns: string[]) {
-    this._contents += '|';
-    columns.forEach((column) => {
-      this._contents += this._replaceInlineReferences(column) + '|';
-    });
-    this.addBlankLine();
-  }
-
-  addListItem(text: string) {
-    this._contents += `* ${text}`;
-  }
-
-  protected static replaceInlineLinks(text: string) {
-    // Parsing text to extract possible linking classes.
-    const possibleLinks = text.match(/<<.*?>>/g);
-    possibleLinks?.forEach((currentMatch) => {
-      const classNameForMatch = currentMatch.replace('<<', '').replace('>>', '');
-      text = text.replace(currentMatch, ClassFileGeneratorHelper.getFileLinkByTypeName(classNameForMatch));
-    });
-
-    // Parsing links using {@link ClassName} format
-    const linkFormatRegEx = '{@link (.*?)}';
-    const expression = new RegExp(linkFormatRegEx, 'gi');
-    let match;
-    const matches = [];
-
-    do {
-      match = expression.exec(text);
-      if (match) {
-        matches.push(match);
-      }
-    } while (match);
-
-    for (const currentMatch of matches) {
-      text = text.replace(currentMatch[0], ClassFileGeneratorHelper.getFileLinkByTypeName(currentMatch[1]));
-    }
-    return text;
-  }
-
-  protected static replaceInlineEmails(text: string) {
-    // Parsing links using {@link ClassName} format
-    const linkFormatRegEx = '{@email (.*?)}';
-    const expression = new RegExp(linkFormatRegEx, 'gi');
-    let match;
-    const matches = [];
-
-    do {
-      match = expression.exec(text);
-      if (match) {
-        matches.push(match);
-      }
-    } while (match);
-
-    for (const currentMatch of matches) {
-      text = text.replace(currentMatch[0], `[${currentMatch[1]}](mailto:${currentMatch[1]})`);
-    }
-    return text;
-  }
-
-  private _replaceInlineReferences(text: string): string {
-    text = MarkdownFile.replaceInlineLinks(text);
-    text = MarkdownFile.replaceInlineEmails(text);
-    return text;
-  }
-}

package/src/model/markdown-generation-util/doc-comment-annotation-util.ts

@@ -1,50 +0,0 @@
-import { DocComment, DocCommentAnnotation } from '@cparra/apex-reflection';
-import ClassFileGeneratorHelper from '../../transpiler/markdown/class-file-generatorHelper';
-import { MarkdownFile } from '../markdown-file';
-
-interface DocCommentAware {
-  docComment?: DocComment;
-}
-
-export function addMermaid(markdownFile: MarkdownFile, docCommentAware: DocCommentAware) {
-  const mermaid = docCommentAware.docComment?.annotations.find((annotation) => annotation.name === 'mermaid');
-  if (!mermaid) {
-    return;
-  }
-
-  markdownFile.addBlankLine();
-  markdownFile.startCodeBlock('mermaid');
-  mermaid.bodyLines.forEach((line) => {
-    markdownFile.addText(line, false);
-  });
-  markdownFile.endCodeBlock();
-  markdownFile.addBlankLine();
-}
-
-export function addCustomDocCommentAnnotations(markdownFile: MarkdownFile, docCommentAware: DocCommentAware) {
-  docCommentAware.docComment?.annotations
-    .filter((currentAnnotation: DocCommentAnnotation) => currentAnnotation.name !== 'description')
-    .filter((currentAnnotation: DocCommentAnnotation) => currentAnnotation.name !== 'mermaid')
-    .forEach((currentAnnotation: DocCommentAnnotation) => {
-      markdownFile.addBlankLine();
-      markdownFile.addText(buildDocAnnotationText(currentAnnotation));
-      markdownFile.addBlankLine();
-    });
-
-  function splitAndCapitalize(text: string) {
-    const words = text.split(/[-_]+/);
-    const capitalizedWords = [];
-    for (const word of words) {
-      capitalizedWords.push(word.charAt(0).toUpperCase() + word.slice(1));
-    }
-    return capitalizedWords.join(' ');
-  }
-
-  function buildDocAnnotationText(annotation: DocCommentAnnotation) {
-    let annotationBodyText = annotation.body;
-    if (annotation.name.toLowerCase() === 'see') {
-      annotationBodyText = ClassFileGeneratorHelper.getFileLinkByTypeName(annotation.body);
-    }
-    return `**${splitAndCapitalize(annotation.name)}** ${annotationBodyText}`;
-  }
-}

package/src/model/markdown-generation-util/field-declaration-util.ts

@@ -1,71 +0,0 @@
-import { MarkdownFile } from '../markdown-file';
-import { FieldMirrorWithInheritance, FieldOrProperty, PropertyMirrorWithInheritance } from '../inheritance';
-
-export function declareField(
-  markdownFile: MarkdownFile,
-  fields: FieldMirrorWithInheritance[] | PropertyMirrorWithInheritance[],
-  startingHeadingLevel: number,
-  grouped = false,
-) {
-  markdownFile.addBlankLine();
-  fields.forEach((propertyModel) => {
-    addFieldSection(markdownFile, propertyModel, startingHeadingLevel, grouped);
-  });
-
-  markdownFile.addHorizontalRule();
-}
-
-function addFieldSection(
-  markdownFile: MarkdownFile,
-  mirrorModel: FieldOrProperty,
-  startingHeadingLevel: number,
-  grouped: boolean,
-) {
-  if (!grouped) {
-    markdownFile.addTitle(
-      `\`${mirrorModel.access_modifier} ${mirrorModel.name}\` → \`${mirrorModel.typeReference.rawDeclaration}\``,
-      startingHeadingLevel + 2,
-    );
-    markdownFile.addBlankLine();
-    if (mirrorModel.inherited) {
-      markdownFile.addText('*Inherited*');
-    }
-
-    mirrorModel.annotations.forEach((annotation) => {
-      markdownFile.addText(`\`${annotation.type.toUpperCase()}\` `);
-    });
-
-    if (mirrorModel.docComment?.description) {
-      markdownFile.addBlankLine();
-      markdownFile.addText(mirrorModel.docComment.description);
-    }
-    markdownFile.addBlankLine();
-  } else {
-    let annotations = '';
-    const hasAnnotations = !!mirrorModel.annotations.length;
-    if (hasAnnotations) {
-      annotations += ' [';
-    }
-    mirrorModel.annotations.forEach((annotation) => {
-      annotations += `\`${annotation.type.toUpperCase()}\` `;
-    });
-    if (hasAnnotations) {
-      annotations += ']';
-    }
-
-    // If grouped we want to display these as a list
-    let description = '';
-    if (mirrorModel.docComment?.description) {
-      description = ` - ${mirrorModel.docComment?.description}`;
-    }
-
-    let listItemText = `\`${mirrorModel.access_modifier} ${mirrorModel.name}\` → \`${mirrorModel.typeReference.rawDeclaration}\``;
-    if (mirrorModel.inherited) {
-      listItemText += '(*Inherited*)';
-    }
-    listItemText += `${annotations} ${description}`;
-
-    markdownFile.addListItem(listItemText);
-    markdownFile.addBlankLine();
-  }
-}

package/src/model/markdown-generation-util/index.ts

@@ -1,3 +0,0 @@
-export * from './type-declaration-util';
-export * from './method-declaration-util';
-export * from './field-declaration-util';