e-pick 1.0.0 → 3.0.0

package/public/js/cherry-pick-builder.js

@@ -0,0 +1,165 @@
+/**
+ * Cherry-Pick Command Builder (Builder Pattern)
+ *
+ * Provides a fluent interface for building cherry-pick command requests
+ * with various options.
+ */
+
+class CherryPickCommandBuilder {
+  constructor() {
+    this._commits = [];
+    this._ignoredCommits = [];
+    this._options = {};
+  }
+
+  /**
+   * Set commits to cherry-pick
+   * @param {string[]} commits - Array of commit hashes
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  withCommits(commits) {
+    this._commits = Array.isArray(commits) ? commits : [commits];
+    return this;
+  }
+
+  /**
+   * Add a single commit
+   * @param {string} commit - Commit hash
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  addCommit(commit) {
+    this._commits.push(commit);
+    return this;
+  }
+
+  /**
+   * Set commits to ignore
+   * @param {string[]} commits - Array of commit hashes to ignore
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  ignoreCommits(commits) {
+    this._ignoredCommits = Array.isArray(commits) ? commits : [commits];
+    return this;
+  }
+
+  /**
+   * Add a single commit to ignore list
+   * @param {string} commit - Commit hash to ignore
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  ignoreCommit(commit) {
+    this._ignoredCommits.push(commit);
+    return this;
+  }
+
+  /**
+   * Allow empty commits in cherry-pick
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  allowEmpty() {
+    this._options.allowEmpty = true;
+    return this;
+  }
+
+  /**
+   * Set merge strategy
+   * @param {string} strategy - Merge strategy (e.g., 'recursive', 'ours', 'theirs')
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  withStrategy(strategy) {
+    this._options.strategy = strategy;
+    return this;
+  }
+
+  /**
+   * Set strategy option
+   * @param {string} option - Strategy option (e.g., 'patience', 'diff-algorithm=patience')
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  withStrategyOption(option) {
+    this._options.strategyOption = option;
+    return this;
+  }
+
+  /**
+   * Perform cherry-pick without committing
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  noCommit() {
+    this._options.noCommit = true;
+    return this;
+  }
+
+  /**
+   * Keep redundant commits (even if empty)
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  keepRedundant() {
+    this._options.keepRedundant = true;
+    return this;
+  }
+
+  /**
+   * Sign off the commit
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  signoff() {
+    this._options.signoff = true;
+    return this;
+  }
+
+  /**
+   * Set custom option
+   * @param {string} key - Option key
+   * @param {any} value - Option value
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  withOption(key, value) {
+    this._options[key] = value;
+    return this;
+  }
+
+  /**
+   * Build the request object
+   * @returns {object} Request object for API
+   */
+  build() {
+    if (this._commits.length === 0) {
+      throw new Error('No commits specified for cherry-pick');
+    }
+
+    return {
+      commits: this._commits,
+      ignoredCommits: this._ignoredCommits,
+      options: this._options
+    };
+  }
+
+  /**
+   * Build and execute the command via API
+   * @param {APIFacade} api - API facade instance
+   * @returns {Promise<object>} Command generation result
+   */
+  async execute(api) {
+    const request = this.build();
+    return await api.generateCommand(
+      request.commits,
+      request.ignoredCommits,
+      request.options
+    );
+  }
+
+  /**
+   * Reset builder to initial state
+   * @returns {CherryPickCommandBuilder} Builder instance for chaining
+   */
+  reset() {
+    this._commits = [];
+    this._ignoredCommits = [];
+    this._options = {};
+    return this;
+  }
+}
+
+// Export for use in other scripts
+window.CherryPickCommandBuilder = CherryPickCommandBuilder;

package/public/js/commit-validator.js

@@ -0,0 +1,183 @@
+/**
+ * Commit Validator (Observer Pattern)
+ *
+ * Handles commit validation logic and API communication
+ * Extends Observable to notify observers of validation progress
+ */
+
+class CommitValidator extends Observable {
+  constructor(apiFacade = null) {
+    super();
+    this.api = apiFacade || new APIFacade();
+    this.validationResults = null;
+    this.ignoredCommits = new Set();
+    // Use commit validation strategy by default (matches original e-pick behavior)
+    this.filterContext = new RepositoryFilterContext(new CommitValidationStrategy());
+  }
+
+  /**
+   * Extract commits with repo information from parsed data
+   * @param {array} rows - Data rows
+   * @param {number} commitColumnIndex - Index of commit column
+   * @param {number} repoColumnIndex - Index of repo column (optional)
+   * @returns {object} Object with commits array and repoData map
+   */
+  extractCommits(rows, commitColumnIndex, repoColumnIndex = null) {
+    const commits = [];
+    const repoData = new Map(); // Map commit hash to repo name
+
+    rows.forEach(row => {
+      const commit = row[commitColumnIndex];
+      const repo = repoColumnIndex !== null ? row[repoColumnIndex] : null;
+
+      if (commit != null && commit !== '') {
+        const trimmedCommit = String(commit).trim();
+        const trimmedRepo = (repo != null && repo !== '') ? String(repo).trim() : null;
+
+        commits.push(trimmedCommit);
+        if (trimmedRepo && trimmedRepo !== 'undefined' && trimmedRepo !== 'null') {
+          repoData.set(trimmedCommit, trimmedRepo);
+        }
+      }
+    });
+
+    // Remove duplicates while preserving repo mapping
+    const uniqueCommits = [...new Set(commits)];
+
+    return {
+      commits: uniqueCommits,
+      repoData
+    };
+  }
+
+  /**
+   * Filter commits by repository using configured strategy
+   * @param {array} commits - Array of commit hashes
+   * @param {Map} repoData - Map of commit to repo name
+   * @returns {Promise<object>} Filtered commits and statistics
+   */
+  async filterByRepo(commits, repoData) {
+    return await this.filterContext.executeFilter(commits, repoData);
+  }
+
+  /**
+   * Set the filtering strategy
+   * @param {BaseFilterStrategy} strategy - Strategy to use for filtering
+   */
+  setFilterStrategy(strategy) {
+    this.filterContext.setStrategy(strategy);
+  }
+
+  /**
+   * Validate commits via API
+   * @param {array} commits - Array of commit hashes
+   * @param {object} filterStats - Repository filtering statistics (optional)
+   * @returns {Promise<object>} Validation results
+   */
+  async validateCommits(commits, filterStats = null) {
+    try {
+      // Notify observers that validation has started
+      this.notify({
+        type: 'start',
+        total: commits.length,
+        message: 'Starting commit validation...'
+      });
+
+      const result = await this.api.validateCommits(commits);
+
+      // Add filter stats to results
+      if (filterStats) {
+        result.filterStats = filterStats;
+      }
+
+      this.validationResults = result;
+
+      // Notify observers that validation is complete
+      this.notify({
+        type: 'complete',
+        total: commits.length,
+        valid: result.summary.valid,
+        invalid: result.summary.invalid,
+        message: `Validation complete: ${result.summary.valid} valid, ${result.summary.invalid} invalid`
+      });
+
+      return result;
+    } catch (error) {
+      // Notify observers of error
+      this.notify({
+        type: 'error',
+        message: error.message
+      });
+
+      throw new Error(`Failed to validate commits: ${error.message}`);
+    }
+  }
+
+  /**
+   * Toggle ignore status for a commit
+   * @param {string} commitHash - Commit hash to toggle
+   */
+  toggleIgnore(commitHash) {
+    if (this.ignoredCommits.has(commitHash)) {
+      this.ignoredCommits.delete(commitHash);
+    } else {
+      this.ignoredCommits.add(commitHash);
+    }
+  }
+
+  /**
+   * Get list of ignored commits
+   * @returns {array} Array of ignored commit hashes
+   */
+  getIgnoredCommits() {
+    return Array.from(this.ignoredCommits);
+  }
+
+  /**
+   * Get valid commits (excluding ignored)
+   * @returns {array} Array of valid commit hashes
+   */
+  getValidCommits() {
+    if (!this.validationResults) {
+      return [];
+    }
+
+    return this.validationResults.results
+      .filter(r => r.isValid && !this.ignoredCommits.has(r.commit))
+      .map(r => r.commit);
+  }
+
+  /**
+   * Generate cherry-pick command
+   * @param {object} options - Cherry-pick options
+   * @returns {Promise<object>} Generated command
+   */
+  async generateCommand(options = {}) {
+    const validCommits = this.getValidCommits();
+
+    if (validCommits.length === 0) {
+      throw new Error('No valid commits to cherry-pick');
+    }
+
+    try {
+      return await this.api.generateCommand(
+        validCommits,
+        this.getIgnoredCommits(),
+        options
+      );
+    } catch (error) {
+      throw new Error(`Failed to generate command: ${error.message}`);
+    }
+  }
+
+  /**
+   * Clear all validation data
+   */
+  clear() {
+    this.validationResults = null;
+    this.ignoredCommits.clear();
+  }
+}
+
+// Export for use in other scripts
+window.CommitValidator = CommitValidator;

package/public/js/file-parser.js

@@ -0,0 +1,30 @@
+/**
+ * File Parser (Factory Pattern + Template Method Pattern)
+ *
+ * Provides a simple API for parsing Excel and CSV files.
+ * Delegates to ParserFactory which uses Template Method pattern internally.
+ */
+
+class FileParser {
+  /**
+   * Parse file using appropriate parser
+   * @param {File} file - File to parse
+   * @returns {Promise<object>} Parsed result
+   */
+  static async parseFile(file) {
+    return await ParserFactory.parseFile(file);
+  }
+
+  /**
+   * Parse specific sheet from Excel file
+   * @param {ExcelParser} parser - Excel parser instance
+   * @param {string} sheetName - Sheet name to parse
+   * @returns {object} Parsed sheet data
+   */
+  static parseSheet(parser, sheetName) {
+    return ParserFactory.parseSheet(parser, sheetName);
+  }
+}
+
+// Export for use in other scripts
+window.FileParser = FileParser;

package/public/js/filter-strategy.js

@@ -0,0 +1,225 @@
+/**
+ * Repository Filter Strategy Pattern
+ *
+ * Provides different strategies for filtering commits by repository
+ */
+
+/**
+ * Base Filter Strategy
+ */
+class BaseFilterStrategy {
+  /**
+   * Filter commits by repository
+   * @param {array} commits - Array of commit hashes
+   * @param {Map} repoData - Map of commit to repo name
+   * @returns {Promise<object>} Filtered commits and statistics
+   */
+  async filter(commits, repoData) {
+    throw new Error('filter() must be implemented by subclass');
+  }
+}
+
+/**
+ * Commit Validation Strategy
+ * Matches repository by validating if commits exist in current repo
+ * (Similar to original e-pick getRepoName logic)
+ */
+class CommitValidationStrategy extends BaseFilterStrategy {
+  constructor(apiFacade = null) {
+    super();
+    this.api = apiFacade || new APIFacade();
+  }
+
+  async filter(commits, repoData) {
+    if (!repoData || repoData.size === 0) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          matchedByCommit: false,
+          strategy: 'no-filter'
+        }
+      };
+    }
+
+    // Get unique repo names from data (filter out null/undefined/non-strings)
+    const repoNames = [...new Set(repoData.values())].filter(name =>
+      name != null && name !== '' && typeof name === 'string'
+    );
+
+    if (repoNames.length === 0) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          matchedByCommit: false,
+          strategy: 'no-valid-repos'
+        }
+      };
+    }
+
+    // Find which repo actually has commits in current repository
+    let matchedRepo = null;
+
+    for (const repoName of repoNames) {
+      // Find a commit from this repo
+      const sampleCommit = commits.find(commit => repoData.get(commit) === repoName);
+
+      if (sampleCommit) {
+        // Check if this commit exists in current repository
+        try {
+          const data = await this.api.checkCommit(sampleCommit);
+
+          if (data.exists) {
+            matchedRepo = repoName;
+            break;
+          }
+        } catch (error) {
+          console.error(`Error checking commit ${sampleCommit}:`, error);
+        }
+      }
+    }
+
+    if (!matchedRepo) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          availableRepos: repoNames,
+          matchedByCommit: false,
+          strategy: 'commit-validation',
+          warning: `No repository matched by commit validation. Using all commits from: ${repoNames.join(', ')}`
+        }
+      };
+    }
+
+    // Filter commits by matched repo
+    const filtered = commits.filter(commit =>
+      repoData.get(commit) === matchedRepo
+    );
+
+    return {
+      filtered,
+      stats: {
+        total: commits.length,
+        matched: filtered.length,
+        filtered: commits.length - filtered.length,
+        matchedRepo,
+        matchedByCommit: true,
+        strategy: 'commit-validation',
+        availableRepos: repoNames
+      }
+    };
+  }
+}
+
+/**
+ * Name Matching Strategy
+ * Simple case-insensitive name matching (fallback strategy)
+ */
+class NameMatchingStrategy extends BaseFilterStrategy {
+  constructor(currentRepoName) {
+    super();
+    this.currentRepoName = currentRepoName;
+  }
+
+  async filter(commits, repoData) {
+    if (!repoData || repoData.size === 0 || !this.currentRepoName) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          matchedByCommit: false,
+          strategy: 'no-filter'
+        }
+      };
+    }
+
+    const repoNames = [...new Set(repoData.values())].filter(name =>
+      name != null && name !== '' && typeof name === 'string'
+    );
+
+    if (repoNames.length === 0) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          matchedByCommit: false,
+          strategy: 'name-matching'
+        }
+      };
+    }
+
+    // Find matching repo (case-insensitive)
+    const matchedRepo = repoNames.find(name =>
+      name && this.currentRepoName &&
+      typeof name === 'string' && typeof this.currentRepoName === 'string' &&
+      name.toLowerCase() === this.currentRepoName.toLowerCase()
+    );
+
+    if (!matchedRepo) {
+      return {
+        filtered: commits,
+        stats: {
+          total: commits.length,
+          matched: commits.length,
+          filtered: 0,
+          availableRepos: repoNames,
+          matchedByCommit: false,
+          strategy: 'name-matching',
+          warning: `No exact match for "${this.currentRepoName}". Using all commits.`
+        }
+      };
+    }
+
+    const filtered = commits.filter(commit =>
+      repoData.get(commit) === matchedRepo
+    );
+
+    return {
+      filtered,
+      stats: {
+        total: commits.length,
+        matched: filtered.length,
+        filtered: commits.length - filtered.length,
+        matchedRepo,
+        matchedByCommit: false,
+        strategy: 'name-matching',
+        availableRepos: repoNames
+      }
+    };
+  }
+}
+
+/**
+ * Filter Context
+ * Manages the filter strategy
+ */
+class RepositoryFilterContext {
+  constructor(strategy) {
+    this.strategy = strategy;
+  }
+
+  setStrategy(strategy) {
+    this.strategy = strategy;
+  }
+
+  async executeFilter(commits, repoData) {
+    return await this.strategy.filter(commits, repoData);
+  }
+}
+
+// Export for use in other scripts
+window.CommitValidationStrategy = CommitValidationStrategy;
+window.NameMatchingStrategy = NameMatchingStrategy;
+window.RepositoryFilterContext = RepositoryFilterContext;

package/public/js/observable.js

@@ -0,0 +1,113 @@
+/**
+ * Observable (Observer Pattern)
+ *
+ * Allows objects to subscribe to and receive notifications about events
+ */
+
+class Observable {
+  constructor() {
+    this.observers = [];
+  }
+
+  /**
+   * Subscribe an observer
+   * @param {object} observer - Observer with update() method
+   * @returns {function} Unsubscribe function
+   */
+  subscribe(observer) {
+    if (typeof observer.update !== 'function') {
+      throw new Error('Observer must have an update() method');
+    }
+
+    this.observers.push(observer);
+
+    // Return unsubscribe function
+    return () => {
+      this.unsubscribe(observer);
+    };
+  }
+
+  /**
+   * Unsubscribe an observer
+   * @param {object} observer - Observer to remove
+   */
+  unsubscribe(observer) {
+    const index = this.observers.indexOf(observer);
+    if (index > -1) {
+      this.observers.splice(index, 1);
+    }
+  }
+
+  /**
+   * Notify all observers
+   * @param {any} data - Data to send to observers
+   */
+  notify(data) {
+    this.observers.forEach(observer => {
+      try {
+        observer.update(data);
+      } catch (error) {
+        console.error('Observer update failed:', error);
+      }
+    });
+  }
+
+  /**
+   * Clear all observers
+   */
+  clearObservers() {
+    this.observers = [];
+  }
+
+  /**
+   * Get observer count
+   * @returns {number} Number of observers
+   */
+  getObserverCount() {
+    return this.observers.length;
+  }
+}
+
+/**
+ * Progress Observer
+ * Specialized observer for tracking progress events
+ */
+class ProgressObserver {
+  constructor(callbacks = {}) {
+    this.callbacks = {
+      onStart: callbacks.onStart || (() => {}),
+      onProgress: callbacks.onProgress || (() => {}),
+      onComplete: callbacks.onComplete || (() => {}),
+      onError: callbacks.onError || (() => {})
+    };
+  }
+
+  /**
+   * Update method called by observable
+   * @param {object} data - Event data
+   */
+  update(data) {
+    const { type } = data;
+
+    switch (type) {
+      case 'start':
+        this.callbacks.onStart(data);
+        break;
+      case 'progress':
+        this.callbacks.onProgress(data);
+        break;
+      case 'complete':
+        this.callbacks.onComplete(data);
+        break;
+      case 'error':
+        this.callbacks.onError(data);
+        break;
+      default:
+        console.warn('Unknown event type:', type);
+    }
+  }
+}
+
+// Export for use in other scripts
+window.Observable = Observable;
+window.ProgressObserver = ProgressObserver;