Merge pull request #1 from adrigar94/feature/new-type-of-skeleton-for-interface

Feature/new type of skeleton for interface

Author: adrigar94

README.md

@@ -1,14 +1,14 @@
 # php-skeleton-generator Extension for Visual Studio Code
 
-Looking for an easy and quick way to generate PHP code skeletons? Check out our "PHP Skeleton Generator" extension! With just a few clicks, you can create PHP classes, interfaces, traits, and enums with all the properties and methods you need. Our assistant guides you through the process, asking you for the options you need and generating the code for you. Save time and effort when creating your PHP projects with "PHP Skeleton Generator"!
+Looking for an easy and quick way to generate PHP code skeletons? Check out our "PHP Skeleton Generator" extension! With just a few steps, you can create PHP classes, interfaces, traits, and enums with all the properties and methods you need. Our assistant guides you through the process, asking you for the options you need and generating the code for you. Save time and effort when creating your PHP projects with "PHP Skeleton Generator"!
 
 ## Features
 
 - Run `php-skeleton-generate` command from the command palette to generate a skeleton for a PHP class
 
 ## Planned Features
 
-- Generate skeleton of other types of PHP files [interface, trait, enum]
+- Generate skeleton of other types of PHP files [trait, enum]
 - Method equal() in Skeleton Class
 
 ## Requirements

src/utils/string.ts

@@ -0,0 +1,12 @@
+export function capitalize(str: string): string {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function capitalizeAndTrim(str: string): string {
+    const words = str.split(' ');
+    let result = "";
+    for (let word of words) {
+        result += capitalize(word);
+    }
+    return result;
+}

src/wizardPhpSkeletons.ts

@@ -1,6 +1,7 @@
 import * as vscode from 'vscode';
 import * as path from 'path';
 import { showFile, writeFile, generateNamespace } from './utils/files';
+import { capitalize, capitalizeAndTrim } from './utils/string';
 
 export async function wizardGeneratePhpSkeleton() {
     const folder = await wizardSelectFolder();
@@ -41,7 +42,7 @@ async function wizardSelectFolder(): Promise<vscode.Uri> {
 async function wizardFileType(): Promise<string> {
     const acceptedTypes = [
         "class",
-        // "interface",
+        "interface",
         // "trait",
         // "enum",
         // "value object (immutable class)"
@@ -60,31 +61,33 @@ async function wizardFileType(): Promise<string> {
 }
 
 async function wizardFileName(type: string): Promise<string> {
-    let className = await vscode.window.showInputBox({
+    let fileName = await vscode.window.showInputBox({
         placeHolder: `Name of ${type}`
     });
-    if (!className) {
-        throw new Error("It is required to provide a name for the class");
+    if (!fileName) {
+        throw new Error("It is required to provide a name for the ${type}");
     }
-    className = capitalizeAndTrim(className);
-    return className;
+    fileName = capitalizeAndTrim(fileName);
+    return fileName;
 }
 
-async function generatePhpSkeleton(type: string, className: string, namespace: string): Promise<string> {
+async function generatePhpSkeleton(type: string, fileName: string, namespace: string): Promise<string> {
     if (type === "class") {
-        return await generatePhpClassSkeleton(className, namespace);
+        return await generatePhpClassSkeleton(fileName, namespace);
+    }
+    if (type === "interface") {
+        return await generatePhpInterfaceSkeleton(fileName, namespace);
     }
     return "## TODO";
 }
 
 async function generatePhpClassSkeleton(className: string, namespace: string): Promise<string> {
-    const properties = await wizardProperties();
+    const properties = await wizardClassProperties();
 
     let declareProperties = [];
     for (const property of properties) {
         declareProperties.push(`${property.visibility} ${property.type} $${property.name}`);
     }
-    const declarePropertiesAsString = declareProperties.join(", ");
 
     let gettersAndSetters = "";
     for (const property of properties) {
@@ -100,15 +103,15 @@ async function generatePhpClassSkeleton(className: string, namespace: string): P
     }`;
     }
 
-    let skeleton = `<?php
+    const skeleton = `<?php
 
 declare(strict_types=1);
 
 namespace ${namespace};
 
 class ${className}
 {
-    public function __construct(${declarePropertiesAsString})
+    public function __construct(${declareProperties.join(", ")})
     {
     }
 
@@ -118,12 +121,7 @@ ${gettersAndSetters}
     return skeleton;
 }
 
-function capitalize(str: string): string {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-}
-
-
-async function wizardProperties(): Promise<Array<{ name: string, visibility: string, type: string }>> {
+async function wizardClassProperties(): Promise<Array<{ name: string, visibility: string, type: string }>> {
     let properties = [];
 
     let input = await vscode.window.showInputBox({
@@ -139,36 +137,93 @@ async function wizardProperties(): Promise<Array<{ name: string, visibility: str
         let visibility = await vscode.window.showQuickPick(
             acceptedVisibilities,
             {
-                placeHolder: "Select the visibility of the property"
+                placeHolder: `Select the visibility of the "${input}" property`
             }
         );
         if (!visibility) {
             visibility = "private";
         }
 
         let type = await vscode.window.showInputBox({
-            prompt: "Enter the type of the property (int, string, etc.)"
+            prompt: `Enter the type of the "${input}" property (int, string, etc.)`
         });
         if (!type) {
             type = "string";
         }
 
-        properties.push({ name: input, visibility: visibility ?? '', type: type ?? '' });
+        properties.push({ name: input, visibility: visibility || '', type: type || '' });
 
         input = await vscode.window.showInputBox({
-            prompt: "Enter a property name (press 'Cancel' or leave empty to finish)"
+            prompt: "Enter another property name (press 'Cancel' or leave empty to finish)"
         });
     }
 
     return properties;
 }
 
+async function generatePhpInterfaceSkeleton(interfaceName: string, namespace: string): Promise<string> {
+
+    const methods = await wizardInterfaceMethods();
+
+    let declareMethods = [];
+    for (const method of methods) {
+        let paramsMethod: Array<string> = [];
+        for (const param of method.params) {
+            paramsMethod.push(`${param.type} $${param.name}`);
+        }
+        declareMethods.push(`    public function ${method.name}(${paramsMethod.join(', ')}): ${method.returnType};`);
+    }
+
+    const skeleton =
+        `<?php
+
+declare(strict_types=1);
+
+namespace ${namespace};
+
+interface ${interfaceName}
+{
+${declareMethods.join("\n\n")}
+}
+`;
+
+    return skeleton;
+}
+
+async function wizardInterfaceMethods(): Promise<Array<{ name: string, returnType: string, params: Array<{ type: string, name: string }> }>> {
+    let methods = [];
+
+    let methodName = await vscode.window.showInputBox({
+        prompt: "Enter a method name (press 'Cancel' or leave empty to finish)"
+    });
+
+    while (methodName) {
+        let params: Array<{ type: string, name: string }> = [];
+
+        const returnType = await vscode.window.showInputBox({
+            prompt: `Enter a return type of "${methodName}" method (default is void)`
+        });
+
+        let paramName = await vscode.window.showInputBox({
+            prompt: `Enter a parameter name of "${methodName}" method (press 'Cancel' or leave empty to finish)`
+        });
+
+        while (paramName) {
+            const paramType = await vscode.window.showInputBox({
+                prompt: `Enter a type of "${paramName}" parameter (int, string, etc.)`
+            });
+            params.push({ type: paramType || '', name: paramName });
+            paramName = await vscode.window.showInputBox({
+                prompt: `Enter another parameter name of "${methodName}" method (press 'Cancel' or leave empty to finish)`
+            });
+        }
+
+        methods.push({ name: methodName, returnType: returnType || 'void', params: params });
 
-function capitalizeAndTrim(str: string): string {
-    const words = str.split(' ');
-    let result = "";
-    for (let word of words) {
-        result += word.charAt(0).toUpperCase() + word.slice(1);
+        methodName = await vscode.window.showInputBox({
+            prompt: "Enter another method name (press 'Cancel' or leave empty to finish)"
+        });
     }
-    return result;
+
+    return methods;
 }