evophp 1.0.2 → 1.0.3

package/helpers.js

@@ -0,0 +1,52 @@
+const readline = require('readline');
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+/**
+ * Prompt user for input with a message
+ * @param {string} msg - The prompt message to display
+ * @returns {Promise<string>} - Resolves with user input
+ */
+const readLineAsync = (msg) => {
+    return new Promise((resolve) => {
+        rl.question(msg, (userRes) => {
+            resolve(userRes);
+            rl.close(); // Ensures the readline interface is closed after resolving
+        });
+    });
+};
+
+/**
+ * Validates and splits the plugin name into [author, pluginName]
+ * @param {string} name - Plugin name or GitHub URL
+ * @returns {Promise<string[]>} - Resolves with an array [author, pluginName]
+ */
+const splitPluginName = async (name) => {
+    const isValidName = (input) =>
+        /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(input);
+
+    let arr = [];
+    while (true) {
+        // Remove common GitHub URL prefixes and trim whitespace
+        name = name.replace(/^(https?:\/\/)?(www\.)?github\.com\//, '').trim();
+
+        if (isValidName(name)) {
+            arr = name.split('/');
+            break;
+        } else {
+            console.log(
+                "Plugin name must include the author's name (e.g., johndoe/exampleplugin)."
+            );
+            name = await readLineAsync("Enter the name of the plugin (or type 'cancel' to exit): ");
+            if (name.toLowerCase() === 'cancel') {
+                console.log("Process canceled by user.");
+                process.exit(1);
+            }
+        }
+    }
+    return arr;
+};
+
+module.exports = { readLineAsync, splitPluginName };

package/install-dependencies.js

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+const { execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const { readLineAsync } = require("./helpers");
+
+let [, , command, type, name, ...args] = process.argv;
+
+(async () => {
+  try {
+    if (command === "i" || command === "install") {
+      if (!name) {
+        console.error("Please specify the plugin or theme name.");
+        process.exit(1);
+      }
+
+      console.log(`Installing ${type}: ${name}...`);
+      
+      if (type === "plugin") {
+        try {
+          execSync(`node install-plugin.js ${name}`, { stdio: "inherit" });
+        } catch (error) {
+          console.error(`Error installing plugin: ${error.message}`);
+          process.exit(1);
+        }
+      } else if (type === "theme") {
+        try {
+          execSync(`node install-theme.js ${name}`, { stdio: "inherit" });
+        } catch (error) {
+          console.error(`Error installing theme: ${error.message}`);
+          process.exit(1);
+        }
+      } else {
+        console.error("Invalid type. Please specify either 'plugin' or 'theme'.");
+        process.exit(1);
+      }
+    } else if (command === "n" || command === "new") {
+      if (!type || !name) {
+        console.error("Please specify both the type (plugin/theme) and name.");
+        process.exit(1);
+      }
+
+      console.log(`Creating a new ${type}: ${name}...`);
+      
+      if (type === "plugin") {
+        try {
+          execSync(`node new-plugin.js ${name}`, { stdio: "inherit" });
+        } catch (error) {
+          console.error(`Error creating new plugin: ${error.message}`);
+          process.exit(1);
+        }
+      } else if (type === "theme") {
+        try {
+          execSync(`node new-theme.js ${name}`, { stdio: "inherit" });
+        } catch (error) {
+          console.error(`Error creating new theme: ${error.message}`);
+          process.exit(1);
+        }
+      } else {
+        console.error("Invalid type. Please specify either 'plugin' or 'theme'.");
+        process.exit(1);
+      }
+    } else if (command === "install-dependencies" || command === "d") {
+      if (!name || !type) {
+        console.error("Please specify both the type (plugin) and name.");
+        process.exit(1);
+      }
+
+      console.log(`Running install-dependencies for ${type}: ${name}...`);
+      
+      if (type === "plugin") {
+        try {
+          execSync(`node install-dependencies.js ${name} ${args.join(' ')}`, { stdio: "inherit" });
+        } catch (error) {
+          console.error(`Error installing dependencies: ${error.message}`);
+          process.exit(1);
+        }
+      } else {
+        console.error("Install-dependencies only supports plugins currently.");
+        process.exit(1);
+      }
+    } else if (command === "init") {
+      if (!name) {
+        name = await readLineAsync("Enter the name of the plugin/project:");
+        if (!name.trim()) {
+          console.error("Invalid name. Please provide a valid project name.");
+          process.exit(1);
+        }
+      }
+
+      console.log(`Initializing new project: ${name}...`);
+
+      try {
+        // Clone the repository
+        console.log("Cloning the Evolution repository...");
+        execSync(
+          `git clone https://github.com/kinsokafor/evolution.git ${name}`,
+          { stdio: "inherit" }
+        );
+
+        // Navigate to the project directory
+        const projectPath = path.join(process.cwd(), name);
+        process.chdir(projectPath);
+
+        // Run `node evolution`
+        console.log(`Running node evolution for project: ${name}...`);
+        execSync(`node evolution ${name}`, { stdio: "inherit" });
+
+        // Install Composer dependencies if applicable
+        if (fs.existsSync("composer.json")) {
+          console.log("Installing Composer dependencies...");
+          execSync("composer install", { stdio: "inherit" });
+        } else {
+          console.log(
+            "Composer file not found, skipping Composer installation."
+          );
+        }
+
+        // Install NPM dependencies
+        console.log("Installing NPM dependencies...");
+        execSync("npm install", { stdio: "inherit" });
+
+        console.log(
+          "Project initialization complete! Navigate to your project folder:"
+        );
+        console.log(`cd ${name}`);
+      } catch (error) {
+        console.error(`Error initializing project: ${error.message}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unknown command: "${command}".`);
+      console.log(`
+        Usage:
+          i | install <plugin/theme> <name>     Install a plugin or theme
+          n | new <plugin/theme> <name>         Create a new plugin or theme
+          d | install-dependencies <plugin> <name>  Install dependencies for a plugin
+          init <name>                           Initialize a new project
+        `);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("An unexpected error occurred:", error.message);
+    process.exit(1);
+  }
+})();

package/install-plugin.js

@@ -0,0 +1,94 @@
+const { execSync } = require('child_process');
+const { readLineAsync, splitPluginName } = require('./helpers');
+const path = require('path');
+const fs = require('fs');
+
+(async () => {
+    try {
+        let [, , type, name] = process.argv;
+
+        // Prompt user for type if not provided
+        if (!type || !['plugin', 'theme'].includes(type.toLowerCase())) {
+            type = await readLineAsync("What are you installing? (plugin/theme): ");
+            type = type.toLowerCase();
+            if (!['plugin', 'theme'].includes(type)) {
+                console.error("Invalid type. Please specify either 'plugin' or 'theme'.");
+                process.exit(1);
+            }
+        }
+
+            
+
+        // Prompt user for name if not provided
+        if (!name) {
+            name = await readLineAsync(
+                `Enter the ${type} name (e.g., johndoe/example${type}): `
+            );
+        }
+
+        // Validate and split the plugin/theme name
+        const [author, itemName] = await splitPluginName(name);
+
+        // Determine installation paths based on type
+        let paths;
+        if (type === 'plugin') {
+            paths = [
+                path.join('Public', 'Module', itemName), // Main plugin path
+                path.join('EvoPhpJs', 'Module', itemName), // .js plugin path
+            ];
+        } else if (type === 'theme') {
+            paths = [path.join('Public', 'Themes', itemName)];
+        }
+
+        // Check if any of the paths already exist
+        for (const pluginPath of paths) {
+            if (fs.existsSync(pluginPath)) {
+                console.log(`The ${type} "${itemName}" already exists at ${pluginPath}.`);
+                process.exit(0);
+            }
+        }
+
+        console.log(`Installing ${type} "${itemName}" by "${author}"...`);
+
+        // Clone repositories based on type
+        if (type === 'plugin') {
+            // Clone the main plugin repository
+            const pluginRepoURL = `https://github.com/${author}/${itemName}.git`;
+            execSync(`git clone ${pluginRepoURL} ${paths[0]}`, { stdio: 'inherit' });
+
+            // Clone the .js plugin repository
+            const jsRepoURL = `https://github.com/${author}/${itemName}.js.git`;
+            execSync(`git clone ${jsRepoURL} ${paths[1]}`, { stdio: 'inherit' });
+
+            // Check for dependencies.json in the .js plugin path
+            const dependenciesFile = path.join(paths[1], 'dependencies.json');
+            if (fs.existsSync(dependenciesFile)) {
+                console.log("Found dependencies.json. Installing dependencies...");
+                const dependencies = JSON.parse(fs.readFileSync(dependenciesFile, 'utf-8'));
+
+                // Install production dependencies
+                if (dependencies.prod) {
+                    console.log("Installing production dependencies...");
+                    execSync(`npm install ${dependencies.prod}`, { stdio: 'inherit', cwd: process.cwd() });
+                }
+
+                // Install development dependencies
+                if (dependencies.dev) {
+                    console.log("Installing development dependencies...");
+                    execSync(`npm install ${dependencies.dev} --save-dev`, { stdio: 'inherit', cwd: process.cwd() });
+                }
+            } else {
+                console.log("No dependencies.json found. Skipping dependency installation.");
+            }
+        } else if (type === 'theme') {
+            // Clone the theme repository
+            const themeRepoURL = `https://github.com/${author}/${itemName}.git`;
+            execSync(`git clone ${themeRepoURL} ${paths[0]}`, { stdio: 'inherit' });
+        }
+
+        console.log(`The ${type} "${itemName}" has been installed successfully.`);
+    } catch (error) {
+        console.error("An error occurred while installing:", error.message);
+        process.exit(1);
+    }
+})();

package/installer.js

@@ -3,40 +3,112 @@
 const { execSync } = require("child_process");
 const path = require("path");
 const fs = require("fs");
+const { readLineAsync } = require("./helpers");
+const axios = require("axios");
+
+let [, , command, type, name] = process.argv;
 
 (async () => {
   try {
-    // Get the project name from command-line arguments or use a default value
-    const projectName = process.argv[2] || "evolution-project";
+    if (command === "i" || command === "install") {
+      if (!name) {
+        console.error("Please specify the plugin or theme name.");
+        process.exit(1);
+      }
 
-    // Clone the repository
-    console.log("Cloning the Evolution repository...");
-    execSync(`git clone https://github.com/kinsokafor/evolution.git ${projectName}`, { stdio: "inherit" });
+      console.log(`Installing plugin/theme: ${name}...`);
+      try {
+        execSync(`node install-plugin.js ${type} ${name}`, {
+          stdio: "inherit",
+        });
+      } catch (error) {
+        console.error(`Error installing plugin/theme: ${error.message}`);
+        process.exit(1);
+      }
+    } else if (command === "n" || command === "new") {
+      // Validate type and name
+      if (!type || !name) {
+        console.error("Please specify the type (plugin/theme) and the name.");
+        process.exit(1);
+      }
 
-    // Navigate to the project directory
-    const projectPath = path.join(process.cwd(), projectName);
-    process.chdir(projectPath);
+      // Ensure valid type is provided (plugin or theme)
+      type = type.toLowerCase();
+      if (!["plugin", "theme"].includes(type)) {
+        console.error(
+          "Invalid type. Please specify either 'plugin' or 'theme'."
+        );
+        process.exit(1);
+      }
 
-    // Run `node evolution` with the project name passed as an argument
-    console.log(`Running node evolution for project: ${projectName}...`);
-    execSync(`node evolution ${projectName}`, { stdio: "inherit" });
+      console.log(`Creating a new ${type}: ${name}...`);
+      try {
+        execSync(`node new-plugin.js ${type} ${name}`, { stdio: "inherit" });
+      } catch (error) {
+        console.error(`Error creating new ${type}: ${error.message}`);
+        process.exit(1);
+      }
+    } else if (command === "init") {
+      if (!name) {
+        name = await readLineAsync("Enter the name of the plugin/project:");
+        if (!name.trim()) {
+          console.error("Invalid name. Please provide a valid project name.");
+          process.exit(1);
+        }
+      }
 
-    // Run `composer install` if composer.json exists
-    if (fs.existsSync("composer.json")) {
-      console.log("Installing Composer dependencies...");
-      execSync("composer install", { stdio: "inherit" });
-    } else {
-      console.log("Composer file not found, skipping Composer installation.");
-    }
+      console.log(`Initializing new project: ${name}...`);
+
+      try {
+        // Clone the repository
+        console.log("Cloning the Evolution repository...");
+        execSync(
+          `git clone https://github.com/kinsokafor/evolution.git ${name}`,
+          { stdio: "inherit" }
+        );
+
+        // Navigate to the project directory
+        const projectPath = path.join(process.cwd(), name);
+        process.chdir(projectPath);
 
-    // Run `npm install`
-    console.log("Installing NPM dependencies...");
-    execSync("npm install", { stdio: "inherit" });
+        // Run `node evolution`
+        console.log(`Running node evolution for project: ${name}...`);
+        execSync(`node evolution ${name}`, { stdio: "inherit" });
 
-    console.log("Installation complete! Navigate to your project folder to get started:");
-    console.log(`cd ${projectName}`);
+        // Install Composer dependencies if applicable
+        if (fs.existsSync("composer.json")) {
+          console.log("Installing Composer dependencies...");
+          execSync("composer install", { stdio: "inherit" });
+        } else {
+          console.log(
+            "Composer file not found, skipping Composer installation."
+          );
+        }
+
+        // Install NPM dependencies
+        console.log("Installing NPM dependencies...");
+        execSync("npm install", { stdio: "inherit" });
+
+        console.log(
+          "Project initialization complete! Navigate to your project folder:"
+        );
+        console.log(`cd ${name}`);
+      } catch (error) {
+        console.error(`Error initializing project: ${error.message}`);
+        process.exit(1);
+      }
+    } else {
+      console.error(`Unknown command: "${command}".`);
+      console.log(`
+        Usage:
+          i | install <type> <name>    Install a plugin or theme
+          n | new <type> <name>        Create a new plugin or theme
+          init <name>                  Initialize a new project
+        `);
+      process.exit(1);
+    }
   } catch (error) {
-    console.error("An error occurred during the installation process:", error.message);
+    console.error("An unexpected error occurred:", error.message);
     process.exit(1);
   }
 })();

package/new-plugin.js

@@ -0,0 +1,148 @@
+const { execSync } = require('child_process');
+const { readLineAsync, splitPluginName } = require('./helpers');
+const path = require('path');
+const fs = require('fs');
+const axios = require('axios');
+
+(async () => {
+    try {
+        let [, , type, name] = process.argv;
+        let cloneDir = ""
+
+        // Ensure type and name are provided
+        if (!type || !name) {
+            console.error("Please specify the type (plugin/theme) and the name (e.g., plugin-name).");
+            process.exit(1);
+        }
+
+        // Prompt for GitHub Personal Access Token (PAT) if not provided in environment variable
+        const gitHubToken = process.env.GITHUB_TOKEN || await readLineAsync("Enter your GitHub Personal Access Token: ");
+        
+        // Validate type - only 'plugin' or 'theme' allowed
+        type = type.toLowerCase();
+        if (!['plugin', 'theme'].includes(type)) {
+            console.error("Invalid type. Please specify either 'plugin' or 'theme'.");
+            process.exit(1);
+        }
+
+        // Validate name and split it into author and item name
+        const [author, itemName] = await splitPluginName(name);
+
+        // Validate PAT by checking the authenticated user's username
+        const userData = await getUserData(gitHubToken);
+
+        if (userData.login !== author) {
+            console.error(`Invalid GitHub token. The token belongs to ${userData.login}, but it should belong to ${author}.`);
+            process.exit(1);
+        }
+
+        console.log(`Authenticated as ${userData.login}. Proceeding with repository creation...`);
+
+        // Define template repository URL based on type
+        let templateRepo = '';
+        if (type === 'plugin') {
+            templateRepo = 'kinsokafor/EvoPlugin';  // Plugin template
+            console.log("Creating a new plugin (EvoPlugin and EvoPlugin.js)...");
+
+            // Create repository for EvoPlugin
+            await createGitHubRepo(gitHubToken, templateRepo, itemName);
+
+            // Clone the newly created repositories
+            cloneDir = path.join('Public', 'Modules', itemName);
+            await cloneRepository(author, itemName, cloneDir);
+
+            // Create repository for EvoPlugin.js (plugin.js)
+            templateRepo = 'kinsokafor/EvoPlugin.js';
+            await createGitHubRepo(gitHubToken, templateRepo, `${itemName}.js`);
+
+            // Clone the newly created repositories
+            cloneDir = path.join('EvoPhpJs', 'Modules', itemName);
+            await cloneRepository(author, itemName, cloneDir);
+
+        } else if (type === 'theme') {
+            templateRepo = 'kinsokafor/EvoTheme';  // Theme template
+            console.log("Creating a new theme (EvoTheme)...");
+
+            // Create repository for EvoTheme
+            await createGitHubRepo(gitHubToken, templateRepo, itemName);
+
+            // Clone the newly created repositories
+            cloneDir = path.join('Public', 'Themes', itemName);
+            await cloneRepository(author, itemName, cloneDir);
+        }
+        
+
+        console.log(`The ${type} "${itemName}" has been set up successfully!`);
+
+    } catch (error) {
+        console.error("An error occurred while setting up the plugin or theme:", error.message);
+        process.exit(1);
+    }
+})();
+
+// Function to create a repository from a template
+async function createGitHubRepo(token, templateRepo, itemName) {
+    try {
+        const response = await axios.post(
+            `https://api.github.com/repos/${templateRepo}/generate`,
+            {
+                name: itemName,
+                private: false,  // Set to true if you want the repository to be private
+                description: `A new ${templateRepo.split('/')[1]} created from template.`,
+            },
+            {
+                headers: {
+                    Authorization: `token ${token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                },
+            }
+        );
+
+        if (response.status === 201) {
+            console.log(`Successfully created the repository: ${itemName} from ${templateRepo}`);
+        } else {
+            console.error('Failed to create the repository:', response.data);
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error(`Error creating repository from ${templateRepo}:`, error.message);
+        process.exit(1);
+    }
+}
+
+// Function to clone the newly created repository
+async function cloneRepository(author, itemName, cloneDir) {
+    try {
+        // Ensure directories do not exist before cloning
+        if (fs.existsSync(cloneDir)) {
+            console.log(`The ${type} "${itemName}" already exists in the directory. Exiting.`);
+            process.exit(0);
+        }
+        
+        const cloneUrl = `https://github.com/${author}/${itemName}.git`;
+
+        console.log(`Cloning the newly created repository from GitHub...`);
+        execSync(`git clone ${cloneUrl} ${cloneDir}`, { stdio: 'inherit' });
+
+        console.log(`Cloned the repository ${itemName} successfully.`);
+    } catch (error) {
+        console.error(`Error cloning the repository ${itemName}:`, error.message);
+        process.exit(1);
+    }
+}
+
+// Function to get user details from GitHub API
+async function getUserData(token) {
+    try {
+        const response = await axios.get('https://api.github.com/user', {
+            headers: {
+                Authorization: `token ${token}`,
+                'Accept': 'application/vnd.github.v3+json',
+            },
+        });
+        return response.data;
+    } catch (error) {
+        console.error('Error fetching user data from GitHub:', error.message);
+        process.exit(1);
+    }
+}

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "evophp",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Installer for the Evolution PHP project",
   "main": "installer.js",
   "scripts": {
     "start": "node installer.js"
   },
   "bin": {
-    "evophp": "./installer.js"
+    "evophp": "installer.js"
   },
-  "dependencies": {}
+  "dependencies": {
+    "axios": "^1.7.9"
+  }
 }