e-pick 1.0.0 → 3.0.0

package/src/validators/commit.validator.js

@@ -0,0 +1,160 @@
+/**
+ * Commit Validator (Chain of Responsibility Pattern)
+ *
+ * Validates commits through a chain of validators.
+ * Each validator checks one aspect of the commit.
+ */
+
+const COMMIT_HASH_REGEX = /^[0-9a-f]{40}$/i;
+
+/**
+ * Base validator class
+ */
+class BaseValidator {
+  constructor() {
+    this.nextValidator = null;
+  }
+
+  /**
+   * Set the next validator in the chain
+   * @param {BaseValidator} validator - Next validator
+   * @returns {BaseValidator} The next validator
+   */
+  setNext(validator) {
+    this.nextValidator = validator;
+    return validator;
+  }
+
+  /**
+   * Validate commit and pass to next validator
+   * @param {string} commitHash - Commit hash to validate
+   * @param {object} context - Validation context
+   * @returns {object} Validation result
+   */
+  async validate(commitHash, context) {
+    const result = await this._validate(commitHash, context);
+
+    if (!result.isValid || !this.nextValidator) {
+      return result;
+    }
+
+    return this.nextValidator.validate(commitHash, context);
+  }
+
+  /**
+   * Internal validation logic (to be implemented by subclasses)
+   * @param {string} commitHash - Commit hash
+   * @param {object} context - Validation context
+   * @returns {object} Validation result
+   * @protected
+   */
+  async _validate(commitHash, context) {
+    throw new Error('_validate method must be implemented');
+  }
+}
+
+/**
+ * Format Validator - Checks if commit hash has valid format
+ */
+class FormatValidator extends BaseValidator {
+  async _validate(commitHash, context) {
+    if (!commitHash || typeof commitHash !== 'string') {
+      return {
+        commit: commitHash,
+        isValid: false,
+        error: {
+          type: 'FORMAT_ERROR',
+          message: 'Commit hash is required and must be a string',
+        },
+        canIgnore: false,
+        commitInfo: null,
+      };
+    }
+
+    const trimmedHash = commitHash.trim();
+
+    if (!COMMIT_HASH_REGEX.test(trimmedHash)) {
+      return {
+        commit: trimmedHash,
+        isValid: false,
+        error: {
+          type: 'FORMAT_ERROR',
+          message: 'Invalid commit hash format. Must be 40 hexadecimal characters',
+        },
+        canIgnore: false,
+        commitInfo: null,
+      };
+    }
+
+    return {
+      commit: trimmedHash,
+      isValid: true,
+      error: null,
+      canIgnore: false,
+      commitInfo: null,
+    };
+  }
+}
+
+/**
+ * Existence Validator - Checks if commit exists in repository
+ */
+class ExistenceValidator extends BaseValidator {
+  async _validate(commitHash, context) {
+    const { gitService } = context;
+
+    if (!gitService) {
+      throw new Error('GitService is required in validation context');
+    }
+
+    const exists = gitService.validateCommit(commitHash);
+
+    if (!exists) {
+      return {
+        commit: commitHash,
+        isValid: false,
+        error: {
+          type: 'NOT_FOUND',
+          message: 'Commit does not exist in repository. It may not have been fetched from remote yet.',
+        },
+        canIgnore: true, // User can ignore if they know the commit should exist
+        commitInfo: null,
+      };
+    }
+
+    // Get commit info for display
+    const commitInfo = gitService.getCommitInfo(commitHash);
+
+    return {
+      commit: commitHash,
+      isValid: true,
+      error: null,
+      canIgnore: false,
+      commitInfo,
+    };
+  }
+}
+
+/**
+ * Create the validation chain
+ * @returns {BaseValidator} The first validator in the chain
+ */
+export function createValidationChain() {
+  const formatValidator = new FormatValidator();
+  const existenceValidator = new ExistenceValidator();
+
+  formatValidator.setNext(existenceValidator);
+
+  return formatValidator;
+}
+
+/**
+ * Validate a single commit
+ * @param {string} commitHash - Commit hash to validate
+ * @param {object} context - Validation context with gitService
+ * @returns {Promise<object>} Validation result
+ */
+export async function validateCommit(commitHash, context) {
+  const chain = createValidationChain();
+  return chain.validate(commitHash, context);
+}

package/cli.js

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-import meow from 'meow';
-import fs from 'fs';
-import pickCommit from './lib/pick-commit.js';
-
-const cli = meow(`
-Usage
-  $ epick [options] <file_path>
-
-<file_path> - Path to the CSV file containing commit and repository information.
-
-Options
-  --commit-index, -c  Index of the commit ID column in the CSV file. Default is 5.
-  --repo-index, -r    Index of the repository name column in the CSV file. Default is 1.
-  --repo-name, -n     Name of the repository to filter commits by. If empty, the first valid repository name found will be used.
-  --execute, -x       Execute the cherry-pick command. Without this flag, the command will only simulate execution.
-  --allow-empty-commit, -a Allows empty commits. Default is false.
-  --verbose, -v       Print detailed logs.
-
-Examples
-  $ epick --commit-index 3 --repo-index 2 --repo-name "your-repo" --execute ./commits.csv
-  Executes the cherry-pick command on the commit of the repository named "your-repo".
-
-  $ epick -c 4 -r 1 -n "example-repo" ./commits.csv
-  Simulates the cherry-pick command for "example-repo".
-`, {
-  importMeta: import.meta,
-  flags: {
-    commitIndex: {
-      type: 'number',
-      shortFlag: 'c',
-      default: 5,
-    },
-    repoIndex: {
-      type: 'number',
-      shortFlag: 'r',
-      default: 1,
-    },
-    repoName: {
-      type: 'string',
-      shortFlag: 'n',
-      default: ''
-    },
-    execute: {
-      type: 'boolean',
-      shortFlag: 'x'
-    },
-    allowEmptyCommit: {
-      type: 'boolean',
-      shortFlag: 'a',
-      default: false
-    },
-    verbose: {
-      type: 'boolean',
-      shortFlag: 'v',
-      default: false
-    },
-  },
-  allowUnknownFlags: false
-});
-
-if (cli.input.length === 0) {
-  console.error("Error: No file path provided. Please specify the path to the CSV file.");
-  process.exit(1);
-}
-
-const filePath = cli.input[0];
-
-if (!fs.existsSync(filePath)) {
-  console.error(`Error: The file "${filePath}" does not exist.`);
-  process.exit(1);
-}
-
-const options = cli.flags;
-
-if (options.verbose) {
-  console.log("Options:", options);
-  console.log("Processing file:", filePath);
-}
-
-await pickCommit(filePath, options);

package/lib/pick-commit.js

@@ -1,162 +0,0 @@
-import fs from 'fs';
-import { execSync } from 'child_process';
-
-const COMMIT_HASH_REGEX = /^[0-9a-f]{40}$/;
-const isValidCommit = (commit_id) => COMMIT_HASH_REGEX.test(commit_id);
-
-const uniqueArray = (array) => [...new Set(array)];
-
-function isExistCommit(commitId, repoPath) {
-  try {
-    // Change the current working directory to the repository path
-    const originalCwd = process.cwd();
-    process.chdir(repoPath);
-
-    // Execute the git command to check the commit type
-    const result = execSync(`git cat-file -t ${commitId}`, { stdio: 'pipe' }).toString().trim();
-
-    // Change back to the original working directory
-    process.chdir(originalCwd);
-
-    // If the command's output starts with "commit", the ID is valid
-    return result === 'commit';
-  } catch (error) {
-    if (error.message.includes('fatal: git cat-file: could not get object info')) {
-      return false;
-    }
-    console.error(error.message);
-    process.exit(error.status || 128);
-  }
-}
-
-function getSheetData({ file_path, commit_index, repo_index }) {
-  // Read the CSV file
-  let csv;
-  try {
-    csv = fs.readFileSync(file_path, 'utf8');
-  } catch (err) {
-    console.error(`Failed to read file ${file_path}`, err);
-    process.exit(1);
-  }
-
-  // Split the CSV data into an array of arrays
-  const rawData = csv
-    .split('\n')
-    .map((line) => line.split('\t').map((item) => item?.trim()))
-    .filter((line) => line.filter(Boolean).length > 2);
-
-  const rows = rawData.map((line) => ({
-    commit_id: line[commit_index],
-    repo_name: line[repo_index],
-  }));
-
-  if (!isValidCommit(rows[0]?.commit_id)) {
-    rows.shift(); // Remove header row
-  }
-  return rows;
-}
-
-function isMatchRepoName(row, selected_repo) {
-  return row?.repo_name?.toLowerCase() === selected_repo.toLowerCase();
-}
-
-/**
- * Extracts and returns the repository name from the provided object.
- *
- * @param {Object} params - The parameters object.
- * @param {string} params.repo_name - The name of the repository to be extracted.
- * @param {Array.<{commit_id: string, repo_name: string}>} params.data - An array of objects,
- * each containing a `commit_id` and a `repo_name`. This parameter is not used in the current implementation.
- *
- * @returns {string} The repository name extracted from the `repo_name` parameter.
- */
-function getRepoName({ repo_name, data }) {
-  if (repo_name) {
-    return repo_name;
-  }
-  const allRepos = uniqueArray(data.map((row) => row.repo_name).filter(Boolean));
-
-  const matchRepos = allRepos.map((name) => {
-    const commitId = data.find((row) => isMatchRepoName(row, name) && row?.commit_id)?.commit_id;
-
-    const isExist = isExistCommit(commitId, process.cwd());
-    return isExist ? name : null;
-  });
-
-  const validRepoName = matchRepos.find(Boolean);
-
-  if (!validRepoName) {
-    console.error('Invalid repo name', 'Please check repoName', allRepos);
-    process.exit(1);
-  }
-
-  return validRepoName;
-}
-
-/**
- * Processes a CSV file containing commit and repository information to generate and optionally execute a git cherry-pick command.
- *
- * This function reads a CSV file specified by the `filePath` parameter, filters the data based on the provided options,
- * and generates a git cherry-pick command for the commits in the selected repository. If the `execute` option is true,
- * the cherry-pick command is executed in the current repository.
- *
- * @param {string} filePath - The path to the CSV file containing commit and repository information.
- * @param {Object} options - An object containing options for processing the CSV file.
- * @param {number} options.commitIndex - The index of the commit ID column in the CSV file.
- * @param {number} options.repoIndex - The index of the repository name column in the CSV file.
- * @param {string} options.repoName - The name of the repository to filter commits by. If empty, the first valid repository name found will be used.
- * @param {boolean} options.execute - If true, the generated cherry-pick command will be executed.
- * @param {boolean} options.allowEmptyCommit - If true, allows do not throw error empty commits.
- */
-export default async function pickCommit(filePath, options) {
-  const { commitIndex, repoIndex, repoName, execute, allowEmptyCommit } = options;
-  // Read the CSV file
-  const data = getSheetData({ file_path: filePath, commit_index: commitIndex, repo_index: repoIndex });
-
-  const selectedRepoName = getRepoName({ repo_name: repoName, data });
-
-  // Check for invalid repo index
-  const dataOfRepo = data.filter((line) => isMatchRepoName(line, selectedRepoName));
-
-  // Check for invalid commit hashes
-  const invalidCommit = dataOfRepo.find((line) => {
-    const commitId = line.commit_id;
-    return !isValidCommit(commitId) && (!allowEmptyCommit || commitId);
-  });
-
-  if (invalidCommit) {
-    console.error('Invalid commit', 'Please check commitIndex', invalidCommit);
-    process.exit(1);
-  }
-
-  // Extract commit hashes
-  const commits = dataOfRepo.map((line) => line.commit_id);
-
-  // Run git show command for each commit
-  const command = `git show -s --format="%ci %H" ${commits.join(' ')}`;
-
-  let output;
-  try {
-    output = execSync(command, { encoding: 'utf8' }).trim();
-  } catch (err) {
-    console.error(`Failed to execute command ${command}`, err);
-    process.exit(1);
-  }
-
-  // Sort the output data by commit date and hash
-  const outputData = output
-    .split('\n')
-    .sort()
-    .map((line) => line.split(' '));
-
-  // Extract sorted commit hashes
-  const sortedCommits = outputData.map((line) => line[3]);
-
-  // Generate cherry-pick command
-  const pickCommand = `git cherry-pick ${sortedCommits.join(' ')}`;
-  console.log(pickCommand);
-
-  if (execute) {
-    execSync(pickCommand, { stdio: 'inherit' });
-  }
-}