ClassManager.ts

import {
    ClassDeclaration,
    ConstructorDeclaration,
    DeclarationVisibility,
    File,
    MethodDeclaration,
    ParameterDeclaration,
    PropertyDeclaration,
    TypescriptCodeGenerator,
    TypescriptParser,
} from 'typescript-parser';
import { Position, Range, TextDocument, TextEdit, workspace, WorkspaceEdit } from 'vscode';

import {
    ClassNotFoundError,
    MethodDuplicated,
    MethodNotFound,
    PropertyDuplicated,
    PropertyNotFound,
} from '../../common/errors';
import { TypescriptCodeGeneratorFactory } from '../../common/factories';
import { Container } from '../IoC';
import { iocSymbols } from '../IoCSymbols';
import { Changeable } from '../proxy-objects/Changeable';
import { getScriptKind } from '../utilities/utilityFunctions';
import { Logger } from '../utilities/winstonLogger';
import { ObjectManager } from './ObjectManager';

type VisibleObject = { visibility?: DeclarationVisibility };

/**
 * Sortfunction for changeable objects. Does sort the objects by visibility.
 *
 * @param {Changeable<VisibleObject>} o1
 * @param {Changeable<VisibleObject>} o2
 * @returns {number}
 */
function sortByVisibility(o1: Changeable<VisibleObject>, o2: Changeable<VisibleObject>): number {
    const left = o1.object.visibility;
    const right = o2.object.visibility;

    if ((left === undefined && right === undefined) || (left === right)) {
        return 0;
    }
    if (left !== undefined && right === undefined) {
        return -1;
    }
    if (left === undefined && right !== undefined) {
        return 1;
    }

    return right! - left!;
}

/**
 * Manager for classes in files. Is able to modify a written class (add / remove methods and properties).
 * On commit, the new typescript is generated and inserted.
 *
 * @export
 * @class ClassManager
 * @implements {ObjectManager}
 */
export class ClassManager implements ObjectManager {
    private static get parser(): TypescriptParser {
        return Container.get<TypescriptParser>(iocSymbols.typescriptParser);
    }

    private static get generator(): TypescriptCodeGenerator {
        return Container.get<TypescriptCodeGeneratorFactory>(iocSymbols.generatorFactory)();
    }

    private static get logger(): Logger {
        return Container.get(iocSymbols.logger);
    }

    private ctor: Changeable<ConstructorDeclaration>;
    private properties: Changeable<PropertyDeclaration>[] = [];
    private methods: Changeable<MethodDeclaration>[] = [];

    private constructor(
        public readonly document: TextDocument,
        public readonly parsedDocument: File,
        private readonly managedClass: ClassDeclaration,
    ) {
        ClassManager.logger.debug(
            '[%s] create class manager',
            ClassManager.name,
            { file: document.fileName, class: managedClass.name },
        );
        this.ctor = new Changeable(managedClass.ctor);
        this.properties = managedClass.properties.map(o => new Changeable(o));
        this.methods = managedClass.methods.map(o => new Changeable(o));
    }

    /**
     * Creates an instance of a ClassManager.
     * Does parse the document text first and returns a promise that
     * resolves to a ClassManager.
     *
     * @static
     * @param {TextDocument} document The document that should be managed
     * @param {string} className The name of the class that should be managed
     * @returns {Promise<ClassManager>}
     *
     * @memberof ClassManager
     */
    public static async create(document: TextDocument, className: string): Promise<ClassManager> {
        const source = await ClassManager.parser.parseSource(document.getText(), getScriptKind(document.fileName));
        const managedClass = source.declarations.find(
            o => o.name === className && o instanceof ClassDeclaration,
        ) as ClassDeclaration;

        if (!managedClass) {
            throw new ClassNotFoundError(className);
        }
        return new ClassManager(document, source, managedClass);
    }

    /**
     * Checks if a property with the given name exists on the virtual class.
     *
     * @param {string} name
     * @returns {boolean}
     *
     * @memberof ClassManager
     */
    public hasProperty(name: string): boolean {
        return this.properties.some(o => o.object.name === name && !o.isDeleted);
    }

    /**
     * Add a property to the virtual class. Creates a Changeable<T> object with the .isNew flag set to true.
     *
     * @param {(string | PropertyDeclaration)} nameOrDeclaration
     * @param {DeclarationVisibility} [visibility]
     * @param {string} [type]
     * @returns {this}
     *
     * @memberof ClassManager
     */
    public addProperty(
        nameOrDeclaration: string | PropertyDeclaration,
        visibility?: DeclarationVisibility,
        type?: string,
    ): this {
        let declaration: PropertyDeclaration;

        if (nameOrDeclaration instanceof PropertyDeclaration) {
            if (this.properties.some(o => o.object.name === nameOrDeclaration.name && !o.isDeleted)) {
                throw new PropertyDuplicated(nameOrDeclaration.name, this.managedClass.name);
            }
            declaration = nameOrDeclaration;
        } else {
            if (this.properties.some(o => o.object.name === nameOrDeclaration && !o.isDeleted)) {
                throw new PropertyDuplicated(nameOrDeclaration, this.managedClass.name);
            }
            declaration = new PropertyDeclaration(nameOrDeclaration, visibility, type);
        }

        this.properties.push(new Changeable(declaration, true));
        ClassManager.logger.debug(
            '[%s] add property to class',
            ClassManager.name,
            { property: declaration.name, class: this.managedClass.name },
        );

        return this;
    }

    /**
     * Remove (aka set isDeleted) a property from the virtual class.
     *
     * @param {string} name
     * @returns {this}
     *
     * @memberof ClassManager
     */
    public removeProperty(name: string): this {
        if (!this.properties.some(o => o.object.name === name && !o.isDeleted)) {
            throw new PropertyNotFound(name, this.managedClass.name);
        }
        const property = this.properties.find(o => o.object.name === name);
        if (!property) {
            return this;
        }
        property.isDeleted = true;
        if (property.isNew) {
            this.properties.splice(this.properties.indexOf(property), 1);
        }
        ClassManager.logger.debug(
            '[%s] remove property from class',
            ClassManager.name,
            { property: name, class: this.managedClass.name },
        );
        return this;
    }

    /**
     * Checks if a method with the given name does exist on the virtual class.
     *
     * @param {string} name
     * @returns {boolean}
     *
     * @memberof ClassManager
     */
    public hasMethod(name: string): boolean {
        return this.methods.some(o => o.object.name === name && !o.isDeleted);
    }

    /**
     * Add a method to the virtual class.
     *
     * @param {(string | MethodDeclaration)} nameOrDeclaration
     * @param {DeclarationVisibility} [visibility]
     * @param {string} [type]
     * @param {ParameterDeclaration[]} [parameters]
     * @returns {this}
     *
     * @memberof ClassManager
     */
    public addMethod(
        nameOrDeclaration: string | MethodDeclaration,
        visibility?: DeclarationVisibility,
        type?: string,
        parameters?: ParameterDeclaration[],
    ): this {
        let declaration: MethodDeclaration;

        if (nameOrDeclaration instanceof MethodDeclaration) {
            if (this.methods.some(o => o.object.name === nameOrDeclaration.name && !o.isDeleted)) {
                throw new MethodDuplicated(nameOrDeclaration.name, this.managedClass.name);
            }
            declaration = nameOrDeclaration;
        } else {
            if (this.methods.some(o => o.object.name === nameOrDeclaration && !o.isDeleted)) {
                throw new MethodDuplicated(nameOrDeclaration, this.managedClass.name);
            }
            declaration = new MethodDeclaration(nameOrDeclaration, false, visibility, type);
            declaration.parameters = parameters || [];
        }

        this.methods.push(new Changeable(declaration, true));
        ClassManager.logger.debug(
            '[%s] add method to class',
            ClassManager.name,
            { property: declaration.name, class: this.managedClass.name },
        );

        return this;
    }

    /**
     * Removes a method from the virtual class.
     *
     * @param {string} name
     * @returns {this}
     *
     * @memberof ClassManager
     */
    public removeMethod(name: string): this {
        if (!this.methods.some(o => o.object.name === name && !o.isDeleted)) {
            throw new MethodNotFound(name, this.managedClass.name);
        }
        const method = this.methods.find(o => o.object.name === name);
        if (!method) {
            return this;
        }
        method.isDeleted = true;
        if (method.isNew) {
            this.methods.splice(this.methods.indexOf(method), 1);
        }
        ClassManager.logger.debug(
            '[%s] remove method from class',
            ClassManager.name,
            { property: name, class: this.managedClass.name },
        );
        return this;
    }

    /**
     * Commits the virtual class to the given document.
     * The following steps are exectued with properties and methods:
     * - Delete properties
     * - Update changed properties (still TODO)
     * - Insert new properties
     *
     * @returns {Promise<boolean>}
     *
     * @memberof ClassManager
     */
    public async commit(): Promise<boolean> {
        const edits = [
            ...this.calculatePropertyEdits(),
            ...this.calculateMethodEdits(),
        ];

        const workspaceEdit = new WorkspaceEdit();
        workspaceEdit.set(this.document.uri, edits);
        ClassManager.logger.debug(
            '[%s] commit the class',
            ClassManager.name,
            { class: this.managedClass.name },
        );
        return workspace.applyEdit(workspaceEdit);
    }

    /**
     * Determines if a propertydeclaration is injected by the constructor.
     * I.e. constructor(public foo: string)...
     *
     * @private
     * @param {PropertyDeclaration} property
     * @returns {boolean}
     *
     * @memberof ClassManager
     */
    private isInConstructor(property: PropertyDeclaration): boolean {
        if (!this.ctor || !this.ctor.object) {
            return false;
        }

        return property.start! >= this.ctor.object.start! && property.end! <= this.ctor.object.end!;
    }

    /**
     * Calculates TextEdits for properties.
     *
     * @private
     * @returns {TextEdit[]}
     *
     * @memberof ClassManager
     */
    private calculatePropertyEdits(): TextEdit[] {
        const edits: TextEdit[] = [];

        for (const property of this.properties.filter(o => o.isDeleted)) {
            edits.push(TextEdit.delete(
                new Range(
                    this.document.lineAt(
                        this.document.positionAt(property.object.start!).line,
                    ).rangeIncludingLineBreak.start,
                    this.document.lineAt(
                        this.document.positionAt(property.object.end!).line,
                    ).rangeIncludingLineBreak.end,
                ),
            ));
        }

        // TODO update

        for (const property of this.properties.filter(o => o.isNew).sort(sortByVisibility)) {
            const lastProperty = this.properties.filter(
                o => !o.isNew &&
                    !o.isDeleted &&
                    !this.isInConstructor(o.object) &&
                    o.object.visibility === property.object.visibility,
            ).pop();
            const lastPosition = lastProperty ?
                this.document.positionAt(lastProperty.object.end!).line + 1 :
                this.document.positionAt(this.managedClass.start!).line + 1;
            edits.push(TextEdit.insert(
                new Position(lastPosition, 0),
                ClassManager.generator.generate(property.object),
            ));
        }

        return edits;
    }

    /**
     * Calculates TextEdits for methods.
     *
     * @private
     * @returns {TextEdit[]}
     *
     * @memberof ClassManager
     */
    private calculateMethodEdits(): TextEdit[] {
        const edits: TextEdit[] = [];

        for (const method of this.methods.filter(o => o.isDeleted)) {
            const endPosition = this.document.positionAt(method.object.end!);
            let endLine = endPosition.line;

            if (this.document.lineAt(endLine + 1).isEmptyOrWhitespace) {
                endLine += 1;
            }

            edits.push(TextEdit.delete(
                new Range(
                    this.document.lineAt(
                        this.document.positionAt(method.object.start!).line,
                    ).rangeIncludingLineBreak.start,
                    this.document.lineAt(endLine).rangeIncludingLineBreak.end,
                ),
            ));
        }

        // TODO update

        for (const method of this.methods.filter(o => o.isNew).sort(sortByVisibility)) {
            const lastMethod = this.methods.filter(
                o => !o.isNew && !o.isDeleted && o.object.visibility === method.object.visibility,
            ).pop();
            const lastPosition = lastMethod ?
                this.document.positionAt(lastMethod.object.end!).line + 1 :
                this.document.positionAt(this.managedClass.end!).line;
            edits.push(TextEdit.insert(
                new Position(lastPosition, 0),
                '\n' + ClassManager.generator.generate(method.object),
            ));
        }

        return edits;
    }
}