add a namespace

Author: adrigar94

CHANGELOG.md

@@ -8,4 +8,5 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ### Added 
 - Initial release
-- Command for create a basic skeleton of PHP class
+- Command for create a basic skeleton of PHP class
+- Add namespace PSR4 in skeleton

README.md

@@ -8,7 +8,6 @@ With this extension, you can quickly generate a skeleton for a PHP class just by
 
 ## Planned Features
 
-- Generate PSR-4 namespace
 - Generate skeleton of other types of PHP files [interface, trait, enum, value object]
 
 ## Requirements

src/utils/files.ts

@@ -1,36 +1,86 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
+import * as fs from 'fs';
 
-export function getPathFile(className: string): vscode.Uri
-{
+export function getCurrentPathFile(className: string): vscode.Uri {
 
     let fsPath = null;
 
-    // Create in current file directory
     if (vscode.window.activeTextEditor) {
         const currentlyOpenTabfileUri = vscode.window.activeTextEditor.document.uri;
         const currentlyOpenTabfileName = path.basename(currentlyOpenTabfileUri.toString());
         fsPath = currentlyOpenTabfileUri.fsPath.replace(currentlyOpenTabfileName, "");
     }
 
-    // Create in root workspace
     if (!fsPath && vscode.workspace.workspaceFolders !== undefined) {
         fsPath = vscode.workspace.workspaceFolders[0].uri.fsPath;
     }
 
     if (!fsPath) {
         throw new Error('Working folder not found, open a folder an try again');
     }
-    
+
     return vscode.Uri.parse(`file:` + path.join(`${fsPath}`, `${className}.php`));
 }
 
-export async function writeFile(pathFile:  vscode.Uri, skeleton: string): Promise<void>
-{
+export async function writeFile(pathFile: vscode.Uri, skeleton: string): Promise<void> {
     await vscode.workspace.fs.writeFile(pathFile, Buffer.from(skeleton));
 }
 
-export function showFile(pathFile:  vscode.Uri): void
-{
+export function showFile(pathFile: vscode.Uri): void {
     vscode.window.showTextDocument(pathFile);
-}
+}
+
+function getRootPath(): string|null
+{
+    if (vscode.workspace.workspaceFolders === undefined) {
+        return null;
+    }
+    return vscode.workspace.workspaceFolders[0].uri.fsPath;
+
+}
+
+function getPsr4(): { [key: string]: string } {
+    const rootPath = getRootPath();
+    if(!rootPath){
+        return {};
+    }
+    const composerJsonPath = path.join(rootPath, `composer.json`);
+    if (!fs.existsSync(composerJsonPath)) {
+        return {};
+    }
+    const composerJsonContent = fs.readFileSync(composerJsonPath, 'utf8');
+
+    const composerJson = JSON.parse(composerJsonContent);
+
+    const autoload = composerJson.autoload;
+
+    if (!autoload || !autoload['psr-4']) {
+        return {};
+    }
+
+    return autoload['psr-4'];
+}
+
+export function generateNamespace(folder: vscode.Uri, fileName: string): string {
+    let folderPath = folder.fsPath;
+    const psr4 = getPsr4();
+
+    const rootPath = getRootPath();
+    folderPath = folderPath.replace(rootPath??'', '');
+    folderPath = folderPath.replace(/\/|\\/g, '\\').replace(/\\/, '');
+
+    for (const prefix of Object.keys(psr4)) {
+        const basePath = psr4[prefix].replace(/\/|\\/g, '\\\\');
+        const prefixRegex = new RegExp(`^${basePath}`);
+
+        if (prefixRegex.test(folderPath)) {
+            const relativePath = folderPath.replace(prefixRegex, '');
+            const namespace = prefix + relativePath;
+            vscode.window.showInformationMessage("in1");
+            return namespace;
+        }
+    }
+    vscode.window.showInformationMessage("out");
+    return folderPath;
+}

src/wizardPhpSkeletons.ts

@@ -1,29 +1,55 @@
 import * as vscode from 'vscode';
-import { getPathFile, showFile, writeFile } from './utils/files';
+import * as path from 'path';
+import { showFile, writeFile, generateNamespace } from './utils/files';
 
 export async function wizardGeneratePhpSkeleton() {
-
+    const folder = await wizardSelectFolder();
     const type = await wizardFileType();
     const fileName = await wizardFileName(type);
-    const classSkeleton = generatePhpSkeleton(type,fileName);
 
-    const pathFile = getPathFile(fileName);
+    const namespace = generateNamespace(folder,fileName);
+
+    const classSkeleton = generatePhpSkeleton(type,fileName,namespace);
+
+    const pathFile =  vscode.Uri.parse(`file:` + path.join(`${folder.fsPath}`, `${fileName}.php`));
 
     await writeFile(pathFile, classSkeleton);
 
     showFile(pathFile);
 }
 
+async function wizardSelectFolder(): Promise<vscode.Uri>
+{
+    if (!vscode.workspace) {
+        throw new Error("Working folder not found, open a folder an try again");
+    }
+    const folder = await vscode.window.showOpenDialog(
+        {
+            canSelectFiles: false,
+            canSelectFolders: true,
+            canSelectMany: false,
+            openLabel: "Select folder where new class should be placed"
+        }
+    );
+
+    if (!folder) {
+        throw new Error("Select the folder where you want create a PHP file");
+    }
+
+    return folder[0];
+}
+
 async function wizardFileType(): Promise<string>
 {
+    const acceptedTypes = [
+        "class",
+        // "interface",
+        // "trait",
+        // "enum",
+        // "value object (immutable class)"
+    ];
     const type = await vscode.window.showQuickPick(
-        [
-            "class",
-            // "interface",
-            // "trait",
-            // "enum",
-            // "value object (immutable class)"
-        ],
+        acceptedTypes,
         {
             placeHolder: "select the type of file you want to create"
         }
@@ -47,18 +73,18 @@ async function wizardFileName(type: string): Promise<string>
     return className;
 }
 
-function generatePhpSkeleton(type: string,className: string): string
+function generatePhpSkeleton(type: string,className: string, namespace: string): string
 {
     if(type === "class"){
-        return generatePhpClassSkeleton(className);
+        return generatePhpClassSkeleton(className, namespace);
     }
     return "## TODO";
 }
 
-function generatePhpClassSkeleton(className: string): string {
+function generatePhpClassSkeleton(className: string, namespace: string): string {
     return `<?php
 
-## TODO: generate namespace
+namespace ${namespace};
 	
 class ${className}
 {