extension.ts

Go to the documentation of this file.

 
import * as path from "path";
import * as vscode from 'vscode';
import { moduleName } from './constants';
import { logger } from './modules/logger';
import { Darling } from "./modules/darling";
import { MorseTranslator } from './modules/morseCode';
import { getMessage } from './modules/messageProvider';
import { LazyFileLoader } from './modules/lazyFileLoad';
import { CommentGenerator } from './modules/commentGenerator';
import { CodeConfig, CodeConfigType } from "./modules/processConfiguration";
import { Watermark } from "./modules/watermark";
import { RandomLogo } from "./modules/randomLogo";
import { query } from "./modules/querier";
 
// Extension boot message
const earlyLog = vscode.window.createOutputChannel('AsperHeader-Preboot');
earlyLog.appendLine('>>> AsperHeader: imports success');
logger.info(getMessage("bootingUp"));
 
// ---- Shared variables ----
 
const updatingDocuments = new WeakSet<vscode.TextDocument>();
earlyLog.appendLine('>>> AsperHeader: WeakSet initialised');
 
const CodeConfiguration: CodeConfigType = CodeConfig;
earlyLog.appendLine('>>> AsperHeader: CodeConfigType initialised');
 
 
// --- Helper functions ---
 
function getFileInfo(editor: vscode.TextEditor) {
    logger.debug(getMessage("inFunction", "getFileInfo"));
    const document = editor.document;
    const filePath = document.uri.fsPath;
    const fileName = document.uri.path.split('/').pop() || "unknown";
    const fileExtension = fileName.includes('.') ? fileName.split('.').pop() : "none";
    const languageId = document.languageId;
 
    return { filePath, fileName, fileExtension, languageId };
}
earlyLog.appendLine('>>> AsperHeader: getFileInfo initialised');
 
// --- Command implementations ---
 
function helloWorldCommand() {
    logger.debug(getMessage("inFunction", "helloWorldCommand"));
    vscode.window.showInformationMessage(getMessage("helloWorldGreetingsCommand", moduleName));
}
earlyLog.appendLine('>>> AsperHeader: helloWorldCommand initialised');
 
async function sayHelloWorldCommand() {
    logger.debug(getMessage("inFunction", "sayHelloWorldCommand"));
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
        logger.Gui.error(getMessage("noActiveEditor"));
        return;
    }
    const { filePath, fileName, fileExtension, languageId } = getFileInfo(editor);
    const message = getMessage("sayHelloWorldResponse", fileExtension, fileName, filePath, languageId);
    await editor.edit(editBuilder => editBuilder.insert(new vscode.Position(0, 0), message));
    logger.Gui.info(getMessage("messageWritten"));
}
earlyLog.appendLine('>>> AsperHeader: sayHelloWorldCommand initialised');
 
async function updateSaveSafe(document: vscode.TextDocument, comment_generator: CommentGenerator) {
    logger.debug(getMessage("inFunction", "updateSaveSafe"));
    if (updatingDocuments.has(document)) {
        return;
    }
    updatingDocuments.add(document);
    try {
        await comment_generator.refreshHeader(document);
        if (document.isDirty) {
            const status = await document.save();
            if (!status) {
                logger.Gui.error(getMessage("fileSaveFailed"));
            }
        }
    } finally {
        updatingDocuments.delete(document);
    }
}
earlyLog.appendLine('>>> AsperHeader: updateSaveSafe initialised');
 
function refreshWorkspaceName() {
    logger.debug(getMessage("inFunction", "refreshWorkspaceName"));
    let workspaceName: string | undefined;
 
    if (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0) {
        workspaceName = vscode.workspace.workspaceFolders[0].name;
    }
    else if ((vscode.workspace as any).rootPath) {
        const rootPath = (vscode.workspace as any).rootPath as string;
        workspaceName = rootPath.split(/[\\/]/).pop();
    }
 
    CodeConfig.setWorkspaceName(workspaceName);
}
earlyLog.appendLine('>>> AsperHeader: refreshWorkspaceName initialised');
 
async function toMorseGui() {
    logger.debug(getMessage("inFunction", "toMorseGui"));
    const usr_input: string | undefined = await query.input(getMessage("toMorseGetInput"));
    if (usr_input === undefined) {
        logger.Gui.info(getMessage("operationCanceled"));
        return;
    }
    const converted_response: string = MorseTranslator.toMorse(usr_input);
    logger.info(getMessage("convertedContentCli", converted_response));
    logger.Gui.info(`${converted_response}`);
    logger.Gui.info(getMessage("convertedContentGui"));
}
earlyLog.appendLine('>>> AsperHeader: toMorseGui initialised');
 
async function fromMorseGui() {
    logger.debug(getMessage("inFunction", "fromMorseGui"));
    const usr_input: string | undefined = await query.input(getMessage("fromMorseGetInput"));
    if (usr_input === undefined) {
        logger.Gui.info(getMessage("operationCanceled"));
        return;
    }
    const converted_response: string = MorseTranslator.fromMorse(usr_input);
    logger.info(getMessage("convertedContentCli", converted_response));
    logger.Gui.info(`${converted_response}`);
    logger.Gui.info(getMessage("convertedContentGui"));
}
earlyLog.appendLine('>>> AsperHeader: fromMorseGui initialised');
 
export async function activate(context: vscode.ExtensionContext) {
    logger.updateInitialisationStatus(true);
    logger.info(getMessage("inActivate"));
    // Initialising the variables of the CodeConfiguration class
    await CodeConfiguration.refreshVariables();
    logger.info(getMessage("variablesRefreshed"));
    // Updating the logger settings
    logger.updateInstallationState(context);
    logger.info(getMessage("inActivateAfterLogger"));
    logger.Gui.debug(`context.extensionPath: ${context.extensionPath}`);
    logger.info(getMessage("inActivateAfterGuiDebug"));
 
    // Class initialisers
    const COMMENTS_FORMAT = new LazyFileLoader<any>();
    logger.debug(getMessage("classInitialised", "LazyFileLoader", moduleName));
    earlyLog.appendLine('>>> AsperHeader: LazyFileLoader initialised');
    const COMMENT_GENERATOR: CommentGenerator = new CommentGenerator(COMMENTS_FORMAT);
    logger.debug(getMessage("classInitialised", "CommentGenerator", moduleName));
    earlyLog.appendLine('>>> AsperHeader: CommentGenerator initialised');
    const DARLING: Darling = new Darling();
    earlyLog.appendLine('>>> AsperHeader: Darling initialised');
    logger.debug(getMessage("classInitialised", "Darling", moduleName));
    const WATERMARK: Watermark = new Watermark();
    earlyLog.appendLine('>>> AsperHeader: Watermark initialised');
    logger.debug(getMessage("classInitialised", "Watermark", moduleName));
    const RANDOM_LOGO: RandomLogo = new RandomLogo();
    earlyLog.appendLine('>>> AsperHeader: RandomLogo initialised');
    logger.debug(getMessage("classInitialised", "RandomLogo", moduleName));
    logger.debug(getMessage("classesInitialised"));
 
    const jsonLanguagePath: string = path.join(
        context.extensionPath,
        "assets",
        "formatingRules",
        "languages.min.json"
    );
    const alternateJsonLanguagePath: string = path.join(
        context.extensionPath,
        "dist",
        "assets",
        "formatingRules",
        "languages.min.json"
    );
    const darlingPath: string = path.join(
        context.extensionPath,
        "assets",
        "bonus",
        "ditf.min.json"
    );
    const alternateDarlingPath: string = path.join(
        context.extensionPath,
        "dist",
        "assets",
        "bonus",
        "ditf.min.json"
    );
    const watermarkPath: string = path.join(
        context.extensionPath,
        "assets",
        "bonus",
        "watermark.min.json"
    );
    const alternateWatermarkPath: string = path.join(
        context.extensionPath,
        "dist",
        "assets",
        "bonus",
        "watermark.min.json"
    );
    const logoPath: string = path.join(
        context.extensionPath,
        "assets",
        "asciiArt"
    );
    const alternateLogoPath: string = path.join(
        context.extensionPath,
        "dist",
        "assets",
        "asciiArt"
    );
    logger.debug(getMessage("pathsSet"));
    // Updating the current working directories of the classes
    await DARLING.updateCurrentWorkingDirectory(context.extensionPath);
    await WATERMARK.updateCurrentWorkingDirectory(context.extensionPath);
    RANDOM_LOGO.updateCurrentWorkingDirectory(context.extensionPath);
    await COMMENTS_FORMAT.updateCurrentWorkingDirectory(context.extensionPath);
    logger.debug(getMessage("currentWorkingDirectorySet"));
    // Updating the default file paths of the classes
    await DARLING.updateFilePath(darlingPath);
    await WATERMARK.updateFilePath(watermarkPath);
    await RANDOM_LOGO.updateRootDir(logoPath, alternateLogoPath);
    await COMMENTS_FORMAT.updateFilePath(jsonLanguagePath);
    logger.debug(getMessage("filePathsAndRootDirsUpdated"));
    // Updating the backup paths of the classes
    await DARLING.updateAlternateFilePath(alternateDarlingPath);
    await WATERMARK.updateAlternateFilePath(alternateWatermarkPath);
    await COMMENTS_FORMAT.updateAlternateFilePath(alternateJsonLanguagePath);
    logger.debug(getMessage("filePathAlternateSet"));
    // Initialising the random logo of the Comment generator class
    COMMENT_GENERATOR.updateLogoInstanceRandomiser(RANDOM_LOGO);
    logger.info(getMessage("extensionActivated", moduleName), 3);
 
 
    context.subscriptions.push(
        vscode.commands.registerCommand(`${moduleName}.helloWorld`, helloWorldCommand),
        vscode.commands.registerCommand(`${moduleName}.sayHelloWorld`, sayHelloWorldCommand),
        vscode.commands.registerCommand(`${moduleName}.injectHeader`, () => { refreshWorkspaceName(); COMMENT_GENERATOR.injectHeader(); }),
        vscode.commands.registerCommand(`${moduleName}.refreshHeader`, () => { refreshWorkspaceName(); COMMENT_GENERATOR.refreshHeader(vscode.window.activeTextEditor?.document); }),
        vscode.commands.registerCommand(`${moduleName}.darling`, DARLING.displayRandomPersonInWindow.bind(DARLING)),
        vscode.commands.registerCommand(`${moduleName}.author`, WATERMARK.displayRandomAuthorWatermarkInWindow.bind(WATERMARK)),
        vscode.commands.registerCommand(`${moduleName}.displayRandomLogo`, RANDOM_LOGO.displayRandomLogoInWindow.bind(RANDOM_LOGO)),
        vscode.commands.registerCommand(`${moduleName}.toMorse`, toMorseGui),
        vscode.commands.registerCommand(`${moduleName}.fromMorse`, fromMorseGui),
        vscode.workspace.onDidSaveTextDocument(async (document: vscode.TextDocument) => { await updateSaveSafe(document, COMMENT_GENERATOR); }),
        vscode.workspace.onDidChangeConfiguration(async (event) => { if (event.affectsConfiguration(moduleName)) { await CodeConfiguration.refreshVariables(); logger.debug(getMessage("variablesRefreshed")); } })
    );
    logger.debug(getMessage("subscriptionsAdded"));
}
earlyLog.appendLine('>>> AsperHeader: activate called');
 
export function deactivate() { }