@pugpigjs/create-wp-project 0.0.2-beta.0

package/src/utils/shared.js

@@ -0,0 +1,359 @@
+import fse from 'fs-extra'
+import path from 'path'
+import os from 'os'
+import ora from 'ora'
+import chalk from 'chalk'
+import simpleGit from 'simple-git'
+import { TEMPLATES, EXCLUDED_ITEMS, EXCLUDE_PATTERNS } from './constants.js'
+
+/**
+ * Validate target directory is safe and meets naming requirements
+ * @param {string} directory - The directory path to validate
+ * @throws {Error} Exits process if validation fails
+ */
+export async function validateTargetDirectory(directory) {
+  const targetDir = path.resolve(directory)
+
+  // Check if directory exists
+  if (!await fse.pathExists(targetDir)) {
+    console.error(chalk.red(`\n❌ Target directory does not exist: ${targetDir}`))
+    console.error(chalk.yellow('Please create the directory first or use an existing one.'))
+    process.exit(1)
+  }
+
+  // Safety check: block system directories
+  const sensitiveDirs = [os.homedir(), '/', '/usr', '/etc', '/var', '/bin', '/sbin']
+  if (sensitiveDirs.includes(targetDir)) {
+    console.error(chalk.red(`\n❌ Cannot operate in system directory: ${targetDir}`))
+    console.error(chalk.yellow('Please use a dedicated project directory.'))
+    process.exit(1)
+  }
+
+  // Safety check: directory name must end with -server
+  const dirName = path.basename(targetDir)
+  if (!dirName?.toLowerCase()?.endsWith('-server')) {
+    console.error(chalk.red(`\n❌ Target directory must end with '-server': ${dirName}`))
+    console.error(chalk.yellow('This is a safety measure to prevent accidental operations in wrong directories.'))
+    console.error(chalk.gray(`Example: my-project-server, wordpress-server, etc.`))
+    process.exit(1)
+  }
+
+  return targetDir
+}
+
+/**
+ * Shared validation functions for prompts
+ */
+export const validators = {
+  namespace: (input) => {
+    if (!input.trim()) return 'Namespace is required'
+    if (!/^[A-Z][a-zA-Z0-9]*$/.test(input)) return 'Namespace must start with uppercase letter and contain only letters and numbers'
+    return true
+  },
+  projectName: (input) => {
+    if (!input.trim()) return 'Project name is required'
+    if (!/^[a-z0-9_]+$/.test(input)) return 'Project name must be in snake_case (lowercase letters, numbers, and underscores only)'
+    if (input.startsWith('_') || input.endsWith('_')) return 'Project name cannot start or end with an underscore'
+    if (input.includes('__')) return 'Project name cannot contain consecutive underscores'
+    return true
+  }
+}
+
+/**
+ * Shared prompt configurations
+ */
+export const prompts = {
+  template: {
+    type: 'list',
+    name: 'template',
+    message: 'Select a template:',
+    choices: Object.entries(TEMPLATES).map(([key, config]) => ({
+      name: `${config.name} - ${config.description}`,
+      value: key
+    }))
+  },
+  namespace: {
+    type: 'input',
+    name: 'namespace',
+    message: 'Enter namespace (e.g., "Pugpig", "Acme"):',
+    default: 'Pugpig',
+    validate: validators.namespace
+  },
+  getProjectNamePrompt: (previousAnswers) => ({
+    type: 'input',
+    name: 'projectName',
+    message: 'Enter project name (snake_case, e.g., "my_custom_plugin"):',
+    validate: (input) => {
+      // First run the basic validation
+      const basicValidation = validators.projectName(input)
+      if (basicValidation !== true) return basicValidation
+
+      // Check if project name starts with namespace prefix
+      if (previousAnswers && previousAnswers.namespace) {
+        const namespacePrefix = `${previousAnswers.namespace.toLowerCase()}_`
+        if (input.startsWith(namespacePrefix)) {
+          return `Project name should not start with "${namespacePrefix}" as the namespace will be automatically prepended to the directory name`
+        }
+      }
+
+      return true
+    }
+  }),
+  description: {
+    type: 'input',
+    name: 'description',
+    message: 'Enter project description:',
+    default: (answers) => {
+      return answers.projectName
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ')
+    }
+  }
+}
+
+/**
+ * Clone the git repository to a temporary directory, or copy from local path
+ * @param {string} gitUrlOrPath - Git URL or local filesystem path
+ * @param {string} tempDir - Temporary directory to clone/copy into
+ */
+export async function cloneRepo(gitUrlOrPath, tempDir) {
+  // Check if it's a local path
+  const isLocalPath = !gitUrlOrPath.startsWith('http://') &&
+                      !gitUrlOrPath.startsWith('https://') &&
+                      !gitUrlOrPath.startsWith('git@')
+
+  console.log(chalk.gray(`  Using temporary directory: ${tempDir}`))
+
+  if (isLocalPath) {
+    const spinner = ora('Copying from local template...').start()
+    try {
+      // Pass tempDir as excludePath to prevent copying the temp directory into itself
+      await copyDirectory(gitUrlOrPath, tempDir, tempDir)
+      spinner.succeed('Local template copied')
+    } catch (error) {
+      spinner.fail('Failed to copy local template')
+      throw error
+    }
+  } else {
+    const spinner = ora('Cloning template repository...').start()
+    try {
+      const git = simpleGit()
+      await git.clone(gitUrlOrPath, tempDir, ['--depth', '1'])
+      spinner.succeed('Template repository cloned')
+    } catch (error) {
+      spinner.fail('Failed to clone repository')
+      throw error
+    }
+  }
+}
+
+/**
+ * Check if a path should be excluded from copying
+ */
+function shouldExclude(itemName) {
+  // Exact match exclusions
+  if (EXCLUDED_ITEMS.includes(itemName)) {
+    return true
+  }
+  // Pattern exclusions: .temp-* directories
+  if (itemName.startsWith('.temp-')) {
+    return true
+  }
+  return false
+}
+
+/**
+ * Copy template directory recursively using fs-extra
+ * Handles the case where target is inside source by copying item-by-item
+ * @param {string} source - Source directory path
+ * @param {string} target - Target directory path
+ * @param {string} [excludePath] - Additional path to exclude (used to prevent copying target into itself)
+ */
+export async function copyDirectory(source, target, excludePath = null) {
+  const resolvedSource = path.resolve(source)
+  const resolvedTarget = path.resolve(target)
+  const resolvedExcludePath = excludePath ? path.resolve(excludePath) : null
+
+  // Check if target is inside source - if so, we need to copy item-by-item
+  const targetIsInsideSource = resolvedTarget.startsWith(resolvedSource + path.sep)
+
+  if (targetIsInsideSource) {
+    // Copy each item individually, skipping the target directory
+    await fse.ensureDir(target)
+    const entries = await fse.readdir(source, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const sourcePath = path.join(source, entry.name)
+      const targetPath = path.join(target, entry.name)
+      const resolvedSourcePath = path.resolve(sourcePath)
+
+      // Skip if this would create a loop
+      if (resolvedSourcePath === resolvedTarget || resolvedSourcePath.startsWith(resolvedTarget + path.sep)) {
+        continue
+      }
+
+      // Skip excluded items
+      if (shouldExclude(entry.name)) {
+        continue
+      }
+
+      // Skip exclude path
+      if (resolvedExcludePath && resolvedSourcePath === resolvedExcludePath) {
+        continue
+      }
+
+      if (entry.isDirectory()) {
+        await copyDirectory(sourcePath, targetPath, excludePath)
+      } else {
+        await fse.copy(sourcePath, targetPath)
+      }
+    }
+  } else {
+    // Normal copy with filter
+    await fse.copy(source, target, {
+      filter: (src) => {
+        const resolvedSrc = path.resolve(src)
+        const basename = path.basename(src)
+
+        // Skip excluded items (both exact matches and patterns)
+        if (shouldExclude(basename)) {
+          return false
+        }
+
+        // Skip if this is the exclude path
+        if (resolvedExcludePath && resolvedSrc === resolvedExcludePath) {
+          return false
+        }
+
+        return true
+      }
+    })
+  }
+}
+
+
+/**
+ * Recursively get all files in a directory, excluding certain patterns
+ * @param {string} dir - Directory to scan
+ * @param {string[]} excludePatterns - Patterns to exclude (e.g., 'node_modules', '.git')
+ * @returns {Promise<string[]>} - Array of file paths
+ */
+async function getAllFiles(dir, excludePatterns = []) {
+  const entries = await fse.readdir(dir, { withFileTypes: true })
+  const files = []
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name)
+
+    // Skip excluded patterns
+    if (excludePatterns.some(pattern => entry.name === pattern || entry.name.startsWith(pattern))) {
+      continue
+    }
+
+    if (entry.isDirectory()) {
+      // Recursively get files from subdirectories
+      const subFiles = await getAllFiles(fullPath, excludePatterns)
+      files.push(...subFiles)
+    } else {
+      files.push(fullPath)
+    }
+  }
+
+  return files
+}
+
+/**
+ * Replace template placeholders in all files (NEW placeholder-based approach)
+ * This is the simplified replacement that works with placeholder-based templates
+ *
+ * @param {string} targetDir - The target directory
+ * @param {string} namespace - The namespace (e.g., "Acme")
+ * @param {string} projectName - The project name (snake_case)
+ * @param {string} description - The project description
+ * @param {string[]} additionalFiles - Optional additional files to process
+ */
+export async function replacePlaceholdersInFiles(targetDir, namespace, projectName, description, additionalFiles = []) {
+  const { replaceInFile: replaceInFilePlaceholder } = await import('./templating.js')
+  const spinner = ora('Replacing template placeholders...').start()
+
+  const directoryName = `${namespace.toLowerCase()}_${projectName}`
+  const values = {
+    namespace,
+    projectName,
+    directoryName,
+    description
+  }
+
+  // Get all files in the target directory, excluding certain patterns
+  const allFiles = await getAllFiles(targetDir, EXCLUDE_PATTERNS)
+
+  // Add any additional files specified (e.g., root files for init)
+  const additionalFilePaths = additionalFiles.map(file => path.join(targetDir, file))
+  const filesToProcess = [...allFiles, ...additionalFilePaths]
+
+  // Apply placeholder replacements to all files
+  let replacedCount = 0
+  for (const filePath of filesToProcess) {
+    const wasReplaced = await replaceInFilePlaceholder(filePath, values)
+    if (wasReplaced) {
+      replacedCount++
+    }
+  }
+
+  spinner.succeed(`Template placeholders replaced (${replacedCount} files updated)`)
+}
+
+/**
+ * Cleanup temporary directory
+ * Now uses directories within project scope for maximum safety
+ */
+export async function cleanup(tempDir) {
+  const basename = path.basename(tempDir)
+
+  // Safety check: only remove directories that look like our temp directories
+  if (!basename.startsWith('.temp-')) {
+    throw new Error(`Refusing to remove directory that doesn't look like a temp directory: ${tempDir}`)
+  }
+
+  // Additional safety: basename must be exactly .temp-{8 hex chars}
+  if (!/^\.temp-[a-f0-9]{8}$/.test(basename)) {
+    throw new Error(`Invalid temp directory format: ${tempDir}`)
+  }
+
+  const spinner = ora('Cleaning up...').start()
+  console.log(chalk.gray(`  Removing temporary directory: ${basename}`))
+  await fse.remove(tempDir)
+  spinner.succeed('Cleanup complete')
+}
+
+/**
+ * Display next steps after project initialization or template addition
+ * @param {string} targetDir - The target directory where files were created
+ * @param {string} projectName - The project name
+ * @param {string} templateType - The template type key
+ * @param {boolean} isInit - Whether this is for init (true) or add (false) command
+ */
+export function displayNextSteps(targetDir, projectName, templateType, isInit = false) {
+  // Calculate relative paths from current working directory
+  const relativePath = path.relative(process.cwd(), targetDir)
+  const cdCommand = relativePath || '.'
+
+  const projectPath = path.join(targetDir, projectName)
+  const relativeProjectPath = path.relative(process.cwd(), projectPath)
+
+  const commitMessage = isInit
+    ? `"Initial commit: Add ${projectName} project"`
+    : `"Add ${projectName} template"`
+
+  console.log(chalk.cyan('Add files to git:'))
+  console.log(chalk.white(`  1. cd ${cdCommand}`))
+  console.log(chalk.white(`  2. git add .`))
+  console.log(chalk.white(`  3. git commit -m ${commitMessage}`))
+  console.log()
+  console.log(chalk.cyan('Run the project:'))
+  console.log(chalk.white(`  1. cd ${relativeProjectPath}`))
+  console.log(chalk.white(`  2. npm ci`))
+  console.log(chalk.white(`  3. npm run ${TEMPLATES[templateType].command}`))
+  console.log()
+}

package/src/utils/templating.js

@@ -0,0 +1,167 @@
+/**
+ * Template placeholder replacement utilities
+ *
+ * This module handles replacing placeholders in template files with actual values.
+ * Uses a simple placeholder approach (__PLACEHOLDER__) instead of complex pattern matching.
+ */
+
+import fse from 'fs-extra'
+import path from 'path'
+import { SKIP_PLACEHOLDER_REPLACEMENT } from './constants.js'
+
+/**
+ * Convert snake_case to PascalCase
+ * @param {string} str - Snake case string
+ * @returns {string} PascalCase string
+ * @example toPascalCase('my_custom_plugin') // 'MyCustomPlugin'
+ */
+function toPascalCase(str) {
+  return str
+    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+    .replace(/^(.)/, (_, char) => char.toUpperCase())
+}
+
+/**
+ * Available placeholder types and their transformations
+ *
+ * Placeholders in template files (case-insensitive):
+ * - TPL_NAMESPACE / tpl_namespace                 - Original namespace (e.g., "Acme")
+ * - TPL_NAMESPACE_LOWER / tpl_namespace_lower     - Lowercase namespace (e.g., "acme")
+ * - TPL_PROJECT_NAME / tpl_project_name           - Project name in snake_case (e.g., "my_custom_plugin")
+ * - TPL_PROJECT_NAME_PASCAL / tpl_project_name_pascal - Project name in PascalCase (e.g., "MyPlugin")
+ * - TPL_PROJECT_NAME_SLUG / tpl_project_name_slug - Project name in kebab-case (e.g., "my-plugin")
+ * - TPL_PROJECT_NAME_FLAT / tpl_project_name_flat - Project name with no separators (e.g., "myplugin")
+ * - TPL_FULL_PROJECT_NAME / tpl_full_project_name - Full project name (e.g., "acme_my_custom_plugin")
+ * - TPL_FULL_PROJECT_NAME_SLUG / tpl_full_project_name_slug - Full name kebab-case (e.g., "acme-my-custom-plugin")
+ * - TPL_FULL_PROJECT_NAME_TITLE / tpl_full_project_name_title - Title Case (e.g., "Acme My Custom Plugin")
+ * - TPL_FULL_PROJECT_NAME_UPPER / tpl_full_project_name_upper - UPPER CASE (e.g., "ACME MY CUSTOM PLUGIN")
+ * - TPL_DESCRIPTION / tpl_description             - Human-readable description (e.g., "My Custom Plugin")
+ * - pkg_* (wildcard)                              - Any pkg_* gets replaced with full project name slug
+ */
+
+/**
+ * Replace all placeholders in content with actual values
+ *
+ * @param {string} content - Template content containing placeholders
+ * @param {object} values - Values to replace placeholders with
+ * @param {string} values.namespace - Namespace (e.g., "Acme")
+ * @param {string} values.projectName - Project name in snake_case (e.g., "my_custom_plugin")
+ * @param {string} values.directoryName - Full directory name (e.g., "acme_my_custom_plugin")
+ * @param {string} values.description - Human-readable description
+ * @returns {string} Content with all placeholders replaced
+ *
+ * @example
+ * const content = 'namespace TPL_NAMESPACE\\TPL_PROJECT_NAME_PASCAL;'
+ * const result = replaceTemplatePlaceholders(content, {
+ *   namespace: 'Acme',
+ *   projectName: 'my_plugin',
+ *   directoryName: 'acme_my_plugin',
+ *   description: 'My Plugin'
+ * })
+ * // Returns: 'namespace Acme\\MyPlugin;'
+ */
+export function replaceTemplatePlaceholders(content, values) {
+  const { namespace, projectName, description } = values
+
+  // Get all placeholder values using the centralised function
+  const placeholders = getPlaceholderValues(namespace, projectName, description)
+
+  // Perform all replacements
+  // Sort keys by length (longest first) to avoid partial replacements
+  // e.g., replace TPL_NAMESPACE_LOWER before TPL_NAMESPACE
+  let result = content
+  const sortedKeys = Object.keys(placeholders).sort((a, b) => b.length - a.length)
+
+  // Replace each placeholder (both uppercase and lowercase variants)
+  for (const key of sortedKeys) {
+    const value = placeholders[key]
+    const placeholderUpper = `TPL_${key}`
+    const placeholderLower = placeholderUpper.toLowerCase()
+
+    // Escape regex special chars and replace both variants
+    result = result.replace(new RegExp(placeholderUpper.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), value)
+    result = result.replace(new RegExp(placeholderLower.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), value)
+  }
+
+  // Replace pkg_* wildcard with full project name slug
+  result = result.replace(/pkg_[a-z_]*/g, placeholders.FULL_PROJECT_NAME_SLUG)
+
+  return result
+}
+
+/**
+ * Get all available placeholder values for a given project
+ * Useful for debugging or displaying what values will be used
+ *
+ * @param {string} namespace - Namespace (e.g., "Acme")
+ * @param {string} projectName - Project name in snake_case
+ * @param {string} description - Human-readable description
+ * @returns {object} Object with all placeholder values
+ *
+ * @example
+ * const values = getPlaceholderValues('Acme', 'my_plugin', 'My Plugin')
+ * console.log(values)
+ * // {
+ * //   NAMESPACE: 'Acme',
+ * //   NAMESPACE_LOWER: 'acme',
+ * //   PROJECT_NAME: 'my_plugin',
+ * //   PROJECT_NAME_PASCAL: 'MyPlugin',
+ * //   ...
+ * // }
+ */
+export function getPlaceholderValues(namespace, projectName, description) {
+  const fullProjectName = `${namespace.toLowerCase()}_${projectName}`
+
+  return {
+    NAMESPACE: namespace,
+    NAMESPACE_LOWER: namespace.toLowerCase(),
+    PROJECT_NAME: projectName,
+    PROJECT_NAME_PASCAL: toPascalCase(projectName),
+    PROJECT_NAME_SLUG: projectName.replace(/_/g, '-'),
+    PROJECT_NAME_FLAT: projectName.replace(/_/g, ''),
+    FULL_PROJECT_NAME: fullProjectName,
+    FULL_PROJECT_NAME_SLUG: fullProjectName.replace(/_/g, '-'),
+    FULL_PROJECT_NAME_TITLE: fullProjectName
+      .split('_')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join(' '),
+    FULL_PROJECT_NAME_UPPER: fullProjectName
+      .split('_')
+      .map(word => word.toUpperCase())
+      .join(' '),
+    DESCRIPTION: description
+  }
+}
+
+/**
+ * Replace placeholders in a single file
+ *
+ * @param {string} filePath - Path to the file
+ * @param {object} values - Placeholder values
+ * @returns {Promise<boolean>} True if file was modified, false otherwise
+ */
+export async function replaceInFile(filePath, values) {
+  try {
+    // Check if this file should be skipped
+    const fileName = path.basename(filePath)
+    if (SKIP_PLACEHOLDER_REPLACEMENT.includes(fileName)) {
+      return false
+    }
+
+    const content = await fse.readFile(filePath, 'utf-8')
+    const updated = replaceTemplatePlaceholders(content, values)
+
+    if (content !== updated) {
+      await fse.writeFile(filePath, updated, 'utf-8')
+      return true
+    }
+
+    return false
+  } catch (error) {
+    // Ignore binary files or read errors
+    if (error.code !== 'EISDIR' && error.code !== 'ENOENT') {
+      console.warn(`Warning: Could not process ${filePath}: ${error.message}`)
+    }
+    return false
+  }
+}