@iamandersonp/prettier-staged 0.2.0

package/README.md

@@ -0,0 +1,176 @@
+# @iamandersonp/prettier-staged
+
+An utitlty to auto format stagged files using prettier
+
+## Installation
+
+To use as a dev dependency
+
+```bash
+npm i -D @iamandersonp/prettier-staged
+```
+
+To use as a global
+
+```bash
+npm i -g @iamandersonp/prettier-staged
+```
+
+## Setup
+
+Create a command on your package.json
+
+```json
+"prettier-staged": "prettier-staged",
+```
+
+## Automatic Hook Installation
+
+When installed as a dependency (not during local development), prettier-staged automatically copies a pre-commit hook to your project's hooks directory. This provides a ready-to-use solution for formatting staged files.
+
+### Configuration
+
+You can configure the hooks directory using an optional `.env` file in your project root:
+
+```bash
+# .env (optional)
+HOOKS_DIR=.git-hooks    # Default value
+# or customize:
+HOOKS_DIR=custom-hooks
+HOOKS_DIR="my hooks"     # With spaces (quotes optional)
+```
+
+If no `.env` file exists, the default directory `.git-hooks` will be used.
+
+#### Setting up your .env file
+
+1. Copy the example configuration:
+
+   ```bash
+   cp .env.example .env
+   ```
+
+2. Edit `.env` to customize your hooks directory (optional):
+
+   ```bash
+   HOOKS_DIR=.git-hooks  # Use default
+   # or
+   HOOKS_DIR=git-hooks   # Custom directory
+   ```
+
+### What gets installed
+
+- A `{HOOKS_DIR}/pre-commit` file that:
+  - Skips formatting during merge conflicts
+  - Formats staged files with Prettier
+  - Re-stages formatted files automatically
+
+### How to use the copied hook
+
+After installation, run this command in your project root to use the copied hook:
+
+```bash
+# Using default .git-hooks directory
+git config core.hooksPath .git-hooks
+```
+
+```bash
+# Or if you customized HOOKS_DIR in .env:
+git config core.hooksPath your-custom-directory
+```
+
+**Pro tip**: The installation script automatically configures Git for you, so this step is usually not needed!
+
+### Hook behavior
+
+- ✅ **Safe**: Only copies if `{HOOKS_DIR}/pre-commit` doesn't exist (won't overwrite)
+- ✅ **Smart**: Only installs when added as a dependency, not during development
+- ✅ **Executable**: Automatically sets proper permissions (`chmod +x`)
+- ✅ **Configurable**: Hooks directory can be customized via `.env` file
+- ✅ **Auto-configured**: Git hooks path is set automatically during installation
+
+### Supported formats in .env
+
+```bash
+# All these formats are valid:
+HOOKS_DIR=.git-hooks          # Basic format
+HOOKS_DIR=".git-hooks"        # With double quotes
+HOOKS_DIR='.git-hooks'        # With single quotes
+HOOKS_DIR=custom-hooks-dir    # Custom directory name
+HOOKS_DIR="hooks with spaces" # Directories with spaces
+```
+
+**Note**: If the `.env` file doesn't exist or has errors, the default `.git-hooks` directory is used automatically.
+
+### Custom implementation
+
+If you prefer a custom implementation, you can create your own pre-commit hook using this example (adjust the hooks directory as needed):
+
+```bash
+#!/bin/sh
+# Replace .git-hooks with your HOOKS_DIR if customized
+
+if git ls-files -u | grep -q .; then
+echo "⚠️  Merge in progress. Skipping Prettier to avoid issues."
+  exit 0
+fi
+
+npm run prettier-staged
+
+STAGED_FILES=$(git diff --name-only --cached --diff-filter=ACM | grep -E '\.(html|ts|scss|css|json)$')
+
+if [ -n "$STAGED_FILES" ]; then
+  echo "$STAGED_FILES" | xargs git add
+fi
+```
+
+### Quick start example
+
+1. **Install the package**:
+
+   ```bash
+   npm install -D @iamandersonp/prettier-staged
+   ```
+
+2. **Optional: Configure hooks directory**:
+
+   ```bash
+   echo "HOOKS_DIR=.git-hooks" > .env
+   ```
+
+3. **The hook is automatically set up!** No additional configuration needed.
+
+4. **Optional: Verify the setup**:
+
+   ```bash
+   git config core.hooksPath  # Should show your hooks directory
+   ls -la .git-hooks/         # Should show the pre-commit hook
+   ```
+
+## Testing
+
+This project includes comprehensive unit tests with Jest. The tests cover all the main functionality and edge cases.
+
+### Available test commands
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode (automatically re-run on file changes)
+npm run test:watch
+
+# Run tests with coverage report
+npm run test:coverage
+```
+
+### Test coverage
+
+Current test coverage: **>95%** including:
+
+- ✅ Successful file formatting scenarios
+- ✅ No files to format scenarios
+- ✅ Error handling (Prettier not found, syntax errors, general errors)
+- ✅ Edge cases (files with spaces, whitespace trimming, all supported extensions)
+
+The tests use mocks to simulate Git commands and Prettier execution without running actual commands, making tests fast and reliable.

package/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional']
+};

package/jest.config.js

@@ -0,0 +1,38 @@
+module.exports = {
+  // Configuración Jest para Node.js CLI tool
+  testEnvironment: 'node',
+
+  // Patrones de archivos de test
+  testMatch: ['**/tests/**/*.test.js', '**/tests/**/*.spec.js', '**/__tests__/**/*.js'],
+
+  // Configuración de coverage
+  collectCoverageFrom: ['src/**/*.js', '!**/node_modules/**', '!**/tests/**'],
+
+  // Threshold mínimo de coverage
+  coverageThreshold: {
+    global: {
+      branches: 85,
+      functions: 85,
+      lines: 85,
+      statements: 85
+    }
+  },
+
+  // Formato de reportes de coverage
+  coverageReporters: ['text', 'html', 'lcov'],
+
+  // Directorio para reportes de coverage
+  coverageDirectory: 'coverage',
+
+  // Limpiar mocks automáticamente después de cada test
+  clearMocks: true,
+
+  // Restaurar mocks automáticamente después de cada test
+  restoreMocks: true,
+
+  // Configuración adicional para mejor output
+  verbose: true,
+
+  // Configuración de timeout para tests
+  testTimeout: 10000
+};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@iamandersonp/prettier-staged",
+  "version": "0.2.0",
+  "main": "src/index.js",
+  "bin": {
+    "prettier-staged": "src/index.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prettier-staged": "src/index.js",
+    "release": "standard-version",
+    "setup:git-hooks": "node src/install-hooks.js",
+    "release:minor": "standard-version --release-as minor",
+    "release:patch": "standard-version --release-as patch",
+    "release:major": "standard-version --release-as major",
+    "postinstall": "npm run setup:git-hooks"
+  },
+  "keywords": [
+    "prettier",
+    "staged",
+    "git",
+    "hooks"
+  ],
+  "author": "Anderson Penaloza <info@iamanderson.dev>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamandersonp/prettier-staged.git"
+  },
+  "homepage": "https://github.com/iamandersonp/prettier-staged.git",
+  "license": "GPL-3.0-only",
+  "description": "An utility to auto format staged files using Prettier",
+  "readme": "README.md",
+  "dependencies": {
+    "prettier": "^3.8.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "jest": "^30.3.0",
+    "standard-version": "^9.5.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { execSync } = require('node:child_process');
+
+const extensions = /\.(html|ts|scss|css|json)$/;
+
+function runPrettierStaged() {
+  try {
+    const output = execSync('git diff --name-only --cached --diff-filter=ACM', {
+      encoding: 'utf-8'
+    });
+
+    const files = output
+      .split('\n')
+      .map((file) => file.trim())
+      .filter((file) => extensions.test(file));
+
+    if (files.length > 0) {
+      console.log('🧼 Formatting staged files with Prettier:');
+      execSync('npx prettier --write ' + files.join(' '), { stdio: 'inherit' });
+
+      // Re-staging
+      execSync(`git add ${files.join(' ')}`);
+    } else {
+      console.log('✅ No staged files matching for formatting.');
+    }
+  } catch (error) {
+    if (error.status === 127) {
+      console.error("❌ Error: Prettier not found. Make sure it's installed:", error.message);
+    } else if (error.status === 2) {
+      console.error('❌ Error: Prettier found syntax errors:', error.message);
+    } else {
+      console.error('❌ Error running Prettier:', error.message);
+    }
+    process.exit(1);
+  }
+}
+
+// Only run if this file is executed directly (not required as a module)
+if (require.main === module) {
+  runPrettierStaged();
+}
+
+module.exports = { runPrettierStaged };

package/src/install-hooks.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Lee el archivo .env para obtener HOOKS_DIR, retorna el valor por defecto si no existe
+ */
+function getHooksDirFromEnv() {
+  const defaultHooksDir = '.git-hooks';
+
+  try {
+    const envPath = path.join(process.cwd(), '.env');
+
+    if (!fs.existsSync(envPath)) {
+      return defaultHooksDir;
+    }
+
+    const envContent = fs.readFileSync(envPath, 'utf8');
+    const lines = envContent.split('\n');
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith('HOOKS_DIR=')) {
+        const value = trimmedLine.substring('HOOKS_DIR='.length).trim();
+        // Remover comillas si existen (simples o dobles)
+        let cleanValue = value
+          .replace(/^['"]/, '') // Remover comilla de inicio
+          .replace(/['"]$/, ''); // Remover comilla de final
+        return cleanValue || defaultHooksDir;
+      }
+    }
+
+    return defaultHooksDir;
+  } catch (error) {
+    // Si hay cualquier error leyendo el archivo, usar valor por defecto
+    console.warn('Warning: Could not read .env file, using default HOOKS_DIR:', error.message);
+    return defaultHooksDir;
+  }
+}
+
+// Constante para el directorio de hooks (lee desde .env o usa valor por defecto)
+const HOOKS_DIR = getHooksDirFromEnv();
+
+/**
+ * Detects if the package is being installed as a dependency in another project
+ * vs being installed during local development
+ */
+function isExternalInstallation() {
+  const initCwd = process.env.INIT_CWD;
+  const currentCwd = process.cwd();
+
+  // If INIT_CWD is different from current working directory,
+  // we're being installed as a dependency
+  return !!(initCwd && initCwd !== currentCwd);
+}
+
+/**
+ * Gets the target project directory (where the package is being installed)
+ */
+function getTargetProjectDir() {
+  // INIT_CWD contains the directory where npm install was run
+  return process.env.INIT_CWD || process.cwd();
+}
+
+/**
+ * Copies the pre-commit hook to the target project's .git-hooks directory
+ * if it doesn't already exist
+ */
+function copyPreCommitHook() {
+  try {
+    const targetProjectDir = getTargetProjectDir();
+    const targetHooksDir = path.join(targetProjectDir, HOOKS_DIR);
+    const targetPreCommitPath = path.join(targetHooksDir, 'pre-commit');
+
+    // Check if pre-commit already exists
+    if (fs.existsSync(targetPreCommitPath)) {
+      console.log(`✅ ${HOOKS_DIR}/pre-commit already exists, skipping copy`);
+      return;
+    }
+
+    // Get source pre-commit path
+    const sourcePreCommitPath = path.join(__dirname, '..', '.git-hooks', 'pre-commit-sample');
+
+    if (!fs.existsSync(sourcePreCommitPath)) {
+      console.warn('⚠️ Source pre-commit hook not found, skipping copy');
+      return;
+    }
+
+    // Ensure target directory exists
+    if (!fs.existsSync(targetHooksDir)) {
+      fs.mkdirSync(targetHooksDir, { recursive: true });
+      console.log(`📁 Created ${HOOKS_DIR} directory`);
+    }
+
+    // Copy the file
+    fs.copyFileSync(sourcePreCommitPath, targetPreCommitPath);
+
+    // Make it executable
+    fs.chmodSync(targetPreCommitPath, 0o755);
+
+    console.log(`✅ Copied pre-commit hook to ${HOOKS_DIR}/pre-commit`);
+    console.log(`💡 To use it, run: git config core.hooksPath ${HOOKS_DIR}`);
+  } catch (error) {
+    // Don't fail installation if hook copy fails
+    console.warn('⚠️ Failed to copy pre-commit hook:', error.message);
+  }
+}
+
+/**
+ * Sets up git hooks in the library's own .git-hooks directory
+ * (existing functionality)
+ */
+function setupLibraryGitHooks() {
+  const { execSync } = require('node:child_process');
+
+  try {
+    // Configure git to use .git-hooks directory
+    execSync(`git config core.hooksPath ${HOOKS_DIR}`, { stdio: 'ignore' });
+    console.log(`✅ Configured git to use ${HOOKS_DIR} directory`);
+
+    // Make hooks executable
+    execSync(`chmod +x ./${HOOKS_DIR}/*`, { stdio: 'ignore' });
+    console.log('✅ Made git hooks executable');
+  } catch (error) {
+    // Silently fail if not in a git repository or permissions issue
+    console.warn('⚠️ Could not setup library git hooks:', error.message);
+  }
+}
+
+/**
+ * Main installation function
+ */
+function installHooks() {
+  console.log('🔧 Setting up prettier-staged hooks...');
+
+  // Always setup hooks for the library itself
+  setupLibraryGitHooks();
+
+  // Only copy to target project if this is an external installation
+  if (isExternalInstallation()) {
+    console.log('📦 Installing as dependency, copying pre-commit hook...');
+    copyPreCommitHook();
+  } else {
+    console.log('🏠 Running in development mode, skipping hook copy');
+  }
+
+  console.log('✨ Setup complete!');
+}
+
+// Export for testing
+module.exports = {
+  isExternalInstallation,
+  getTargetProjectDir,
+  copyPreCommitHook,
+  setupLibraryGitHooks,
+  installHooks,
+  getHooksDirFromEnv,
+  HOOKS_DIR
+};
+
+// Run if called directly
+if (require.main === module) {
+  installHooks();
+}

package/tests/index.test.js

@@ -0,0 +1,233 @@
+const { execSync } = require('node:child_process');
+
+// Mock completo del módulo child_process
+jest.mock('node:child_process', () => ({
+  execSync: jest.fn()
+}));
+
+const { runPrettierStaged } = require('../src/index.js');
+
+describe('prettier-staged CLI', () => {
+  let consoleSpy, errorSpy, exitSpy;
+
+  beforeEach(() => {
+    // Reset all mocks
+    jest.clearAllMocks();
+
+    // Setup console spies
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    errorSpy = jest.spyOn(console, 'error').mockImplementation();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation();
+  });
+
+  afterEach(() => {
+    // Restore all spies
+    consoleSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  describe('Successful formatting', () => {
+    test('should format staged files with valid extensions', () => {
+      // Mock git diff to return files with valid extensions
+      execSync
+        .mockReturnValueOnce('src/app.ts\nstyles/main.scss\nconfig.json\n')
+        .mockReturnValueOnce(undefined) // prettier command
+        .mockReturnValueOnce(undefined); // git add command
+
+      // Execute the function
+      runPrettierStaged();
+
+      // Verify git diff was called
+      expect(execSync).toHaveBeenNthCalledWith(
+        1,
+        'git diff --name-only --cached --diff-filter=ACM',
+        { encoding: 'utf-8' }
+      );
+
+      // Verify prettier was called with correct files
+      expect(execSync).toHaveBeenNthCalledWith(
+        2,
+        'npx prettier --write src/app.ts styles/main.scss config.json',
+        { stdio: 'inherit' }
+      );
+
+      // Verify git add was called with formatted files
+      expect(execSync).toHaveBeenNthCalledWith(
+        3,
+        'git add src/app.ts styles/main.scss config.json'
+      );
+
+      // Verify success message
+      expect(consoleSpy).toHaveBeenCalledWith('🧼 Formatting staged files with Prettier:');
+      expect(exitSpy).not.toHaveBeenCalled();
+    });
+
+    test('should handle single file with valid extension', () => {
+      execSync
+        .mockReturnValueOnce('index.html\n')
+        .mockReturnValueOnce(undefined)
+        .mockReturnValueOnce(undefined);
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenNthCalledWith(2, 'npx prettier --write index.html', {
+        stdio: 'inherit'
+      });
+      expect(consoleSpy).toHaveBeenCalledWith('🧼 Formatting staged files with Prettier:');
+    });
+  });
+
+  describe('No files to format', () => {
+    test('should show message when no staged files', () => {
+      execSync.mockReturnValueOnce('\n'); // Empty git diff output
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenCalledTimes(1);
+      expect(consoleSpy).toHaveBeenCalledWith('✅ No staged files matching for formatting.');
+      expect(exitSpy).not.toHaveBeenCalled();
+    });
+
+    test('should show message when staged files have invalid extensions', () => {
+      execSync.mockReturnValueOnce('README.md\nscript.py\nimage.png\n');
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenCalledTimes(1);
+      expect(consoleSpy).toHaveBeenCalledWith('✅ No staged files matching for formatting.');
+      expect(exitSpy).not.toHaveBeenCalled();
+    });
+
+    test('should filter mixed files and format only valid ones', () => {
+      execSync
+        .mockReturnValueOnce('README.md\nsrc/app.ts\nimage.png\nstyle.css\n')
+        .mockReturnValueOnce(undefined)
+        .mockReturnValueOnce(undefined);
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenNthCalledWith(2, 'npx prettier --write src/app.ts style.css', {
+        stdio: 'inherit'
+      });
+      expect(consoleSpy).toHaveBeenCalledWith('🧼 Formatting staged files with Prettier:');
+    });
+  });
+
+  describe('Error handling', () => {
+    test('should handle Prettier not found error (status 127)', () => {
+      execSync.mockReturnValueOnce('src/app.ts\n');
+
+      const error = new Error('prettier: command not found');
+      error.status = 127;
+      execSync.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      runPrettierStaged();
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "❌ Error: Prettier not found. Make sure it's installed:",
+        error.message
+      );
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    test('should handle Prettier syntax errors (status 2)', () => {
+      execSync.mockReturnValueOnce('src/broken.ts\n');
+
+      const error = new Error('Syntax error in file');
+      error.status = 2;
+      execSync.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      runPrettierStaged();
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        '❌ Error: Prettier found syntax errors:',
+        error.message
+      );
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    test('should handle general Prettier errors', () => {
+      execSync.mockReturnValueOnce('src/app.ts\n');
+
+      const error = new Error('General prettier error');
+      error.status = 1;
+      execSync.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      runPrettierStaged();
+
+      expect(errorSpy).toHaveBeenCalledWith('❌ Error running Prettier:', error.message);
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    test('should handle git command errors', () => {
+      const error = new Error('Git command failed');
+      error.status = 128;
+      execSync.mockImplementationOnce(() => {
+        throw error;
+      });
+
+      runPrettierStaged();
+
+      expect(errorSpy).toHaveBeenCalledWith('❌ Error running Prettier:', error.message);
+      expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should handle files with spaces in names', () => {
+      execSync
+        .mockReturnValueOnce('src/my file.ts\nother file.css\n')
+        .mockReturnValueOnce(undefined)
+        .mockReturnValueOnce(undefined);
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenNthCalledWith(
+        2,
+        'npx prettier --write src/my file.ts other file.css',
+        { stdio: 'inherit' }
+      );
+    });
+
+    test('should trim whitespace from file names', () => {
+      execSync
+        .mockReturnValueOnce('  src/app.ts  \n  style.css  \n\n')
+        .mockReturnValueOnce(undefined)
+        .mockReturnValueOnce(undefined);
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenNthCalledWith(2, 'npx prettier --write src/app.ts style.css', {
+        stdio: 'inherit'
+      });
+    });
+
+    test('should handle all supported file extensions', () => {
+      const validFiles = [
+        'template.html',
+        'component.ts',
+        'styles.scss',
+        'reset.css',
+        'package.json'
+      ];
+
+      execSync
+        .mockReturnValueOnce(validFiles.join('\n') + '\n')
+        .mockReturnValueOnce(undefined)
+        .mockReturnValueOnce(undefined);
+
+      runPrettierStaged();
+
+      expect(execSync).toHaveBeenNthCalledWith(2, `npx prettier --write ${validFiles.join(' ')}`, {
+        stdio: 'inherit'
+      });
+    });
+  });
+});