semver-ratchet 1.0.0

package/src/git_mock.js

@@ -0,0 +1,348 @@
+/**
+ * Mock Git implementation for testing semver-ratchet.
+ *
+ * This module provides an in-memory mock implementation of GitAdapter
+ * that simulates git operations without requiring a real repository.
+ */
+
+import { GitAdapter } from './git_adapter.js';
+
+/**
+ * In-memory mock implementation of GitAdapter for testing.
+ *
+ * This mock simulates git operations without requiring a real repository,
+ * allowing for deterministic and isolated tests.
+ *
+ * Example usage:
+ * ```javascript
+ * const mock = new MockGitAdapter();
+ * mock.setBranch('feature/test');
+ * mock.addCommit('Fix bug');
+ * mock.createTag('1.0.0');
+ * assert.equal(mock.getLatestTag(), '1.0.0');
+ * ```
+ */
+export class MockGitAdapter extends GitAdapter {
+  /**
+   * Initialize the mock git adapter with default state.
+   */
+  constructor() {
+    super();
+    this._currentBranch = 'main';
+    this._branches = {
+      main: [],
+      master: [],
+    };
+    this._tags = {}; // tag_name -> commit_hash
+    this._defaultBranch = 'main';
+    this._historyVerified = true;
+    this._fetchDepth = 50;
+    this._tagCreationOrder = [];
+    this._pushedTags = [];
+    this._remoteConfigured = false;
+  }
+
+  /**
+   * Reset all state to defaults.
+   */
+  reset() {
+    this._currentBranch = 'main';
+    this._branches = { main: [], master: [] };
+    this._tags = {};
+    this._defaultBranch = 'main';
+    this._historyVerified = true;
+    this._fetchDepth = 50;
+    this._tagCreationOrder = [];
+    this._pushedTags = [];
+    this._remoteConfigured = false;
+  }
+
+  /**
+   * Set the current branch.
+   * @param {string} branchName - Name of the branch to switch to
+   */
+  setBranch(branchName) {
+    this._currentBranch = branchName;
+    if (!(branchName in this._branches)) {
+      this._branches[branchName] = [];
+    }
+  }
+
+  /**
+   * Set the default/main branch name.
+   * @param {string} branchName - Name of the main branch (e.g., "main" or "master")
+   */
+  setDefaultBranch(branchName) {
+    this._defaultBranch = branchName;
+    if (!(branchName in this._branches)) {
+      this._branches[branchName] = [];
+    }
+  }
+
+  /**
+   * Add a commit to the current (or specified) branch.
+   * @param {string} message - Commit message
+   * @param {string} [branch] - Optional branch name (defaults to current branch)
+   */
+  addCommit(message, branch = null) {
+    const targetBranch = branch || this._currentBranch;
+    if (!(targetBranch in this._branches)) {
+      this._branches[targetBranch] = [];
+    }
+    this._branches[targetBranch].push(message);
+  }
+
+  /**
+   * Create a tag internally (without printing).
+   * @param {string} version - Version string (without 'v' prefix)
+   * @private
+   */
+  _createTagInternal(version) {
+    const tagName = `v${version}`;
+
+    // Tag points to the latest commit on the branch
+    const commits = this._branches[this._currentBranch];
+    if (commits && commits.length > 0) {
+      this._tags[tagName] = commits[commits.length - 1];
+    } else {
+      // Create a synthetic commit hash for empty branches
+      this._tags[tagName] = `tag_${version}_no_commits`;
+    }
+
+    this._tagCreationOrder.push(tagName);
+  }
+
+  /**
+   * Create a tag on the current branch.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @param {boolean} [force=false] - If true, overwrite existing tag
+   * @returns {boolean} True if tag was created successfully
+   */
+  createTag(version, force = false) {
+    const tagName = `v${version}`;
+
+    if (tagName in this._tags) {
+      if (force) {
+        // Overwrite existing tag
+        this._createTagInternal(version);
+        console.log(`Created tag v${version} (forced)`);
+        return true;
+      } else {
+        console.log(`Tag v${version} already exists. Use --force to overwrite.`);
+        return false;
+      }
+    } else {
+      // Create new tag
+      this._createTagInternal(version);
+      console.log(`Created tag v${version}`);
+      return true;
+    }
+  }
+
+  /**
+   * Delete a tag.
+   * @param {string} version - Version string (without 'v' prefix)
+   */
+  deleteTag(version) {
+    const tagName = `v${version}`;
+    if (tagName in this._tags) {
+      delete this._tags[tagName];
+      this._tagCreationOrder = this._tagCreationOrder.filter(t => t !== tagName);
+    }
+  }
+
+  /**
+   * Set multiple tags at once.
+   * @param {string[]} tags - List of version strings (without 'v' prefix)
+   */
+  setTags(tags) {
+    for (const version of tags) {
+      this._createTagInternal(version);
+    }
+  }
+
+  /**
+   * Set commit messages for a branch.
+   * @param {string[]} messages - List of commit messages
+   * @param {string} [branch] - Optional branch name (defaults to current branch)
+   */
+  setCommitMessages(messages, branch = null) {
+    const targetBranch = branch || this._currentBranch;
+    this._branches[targetBranch] = [...messages];
+  }
+
+  /**
+   * Set whether git history verification should succeed.
+   * @param {boolean} verified - True if history is sufficient
+   */
+  setHistoryVerified(verified) {
+    this._historyVerified = verified;
+  }
+
+  /**
+   * Set the required fetch depth for history verification.
+   * @param {number} depth - Minimum number of commits required
+   */
+  setFetchDepth(depth) {
+    this._fetchDepth = depth;
+  }
+
+  /**
+   * Set whether a remote is configured.
+   * @param {boolean} configured - True if remote is configured
+   */
+  setRemoteConfigured(configured) {
+    this._remoteConfigured = configured;
+  }
+
+  /**
+   * Get the current branch name.
+   * @returns {string} The branch name
+   */
+  getCurrentBranch() {
+    return this._currentBranch;
+  }
+
+  /**
+   * Check if current branch is main or master.
+   * @returns {boolean} True if on main/master branch
+   */
+  isMainBranch() {
+    return this._currentBranch.toLowerCase() === 'main' || this._currentBranch.toLowerCase() === 'master';
+  }
+
+  /**
+   * Calculate the number of commits between HEAD and main branch.
+   * @returns {number} Number of commits
+   */
+  getGitDistance() {
+    if (this.isMainBranch()) {
+      return 0;
+    }
+
+    const currentBranch = this._currentBranch;
+    const currentCommits = this._branches[currentBranch] || [];
+
+    // Simple distance calculation: commits on current branch
+    // In a real scenario, this would be more complex with merge tracking
+    return currentCommits.length;
+  }
+
+  /**
+   * Get the latest SemVer tag on the current branch.
+   * @returns {string|null} Tag version without 'v' prefix, or null if no tags
+   */
+  getLatestTag() {
+    if (this._tagCreationOrder.length === 0) {
+      return null;
+    }
+
+    // Return the last tag created (simple implementation)
+    const lastTag = this._tagCreationOrder[this._tagCreationOrder.length - 1];
+    return lastTag.substring(1); // Strip 'v' prefix
+  }
+
+  /**
+   * Get commit messages since a specific tag or all commits.
+   * @param {string} [sinceTag] - Optional tag to start from (without 'v' prefix)
+   * @returns {string[]} List of commit messages
+   */
+  getCommitMessages(sinceTag = null) {
+    const currentBranch = this._currentBranch;
+    const messages = this._branches[currentBranch] || [];
+
+    if (!sinceTag) {
+      return [...messages];
+    }
+
+    // Find commits after the tag
+    const tagName = `v${sinceTag}`;
+    if (!(tagName in this._tags)) {
+      return [...messages];
+    }
+
+    // Simple implementation: return all messages if tag exists
+    // A more sophisticated mock would track commit positions
+    return [...messages];
+  }
+
+  /**
+   * Verify that enough git history is available.
+   * @param {number} [fetchDepth=50] - Minimum number of commits required
+   * @returns {boolean} True if sufficient history exists
+   * @throws {Error} If history is insufficient
+   */
+  verifyGitHistory(fetchDepth = 50) {
+    if (!this._historyVerified) {
+      throw new Error('Insufficient git history: mock history verification disabled');
+    }
+
+    // Check if we have enough commits
+    const currentBranch = this._currentBranch;
+    const commits = this._branches[currentBranch] || [];
+
+    if (commits.length < fetchDepth) {
+      throw new Error(
+        `Insufficient git history: ${commits.length} commits found, ` +
+        `need at least ${fetchDepth} for accurate version calculation`,
+      );
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if a tag exists for the given version.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @returns {boolean} True if tag exists
+   */
+  tagExists(version) {
+    const tagName = `v${version}`;
+    return tagName in this._tags;
+  }
+
+  /**
+   * Push a tag to the remote repository.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @param {string} [remote='origin'] - Remote name to push to
+   * @throws {Error} If tag doesn't exist or remote not configured
+   */
+  pushTag(version, remote = 'origin') {
+    const tagName = `v${version}`;
+    if (!(tagName in this._tags)) {
+      throw new Error(`Tag v${version} does not exist, cannot push`);
+    }
+
+    if (!this._remoteConfigured) {
+      throw new Error('No remote configured, cannot push');
+    }
+
+    this._pushedTags.push(tagName);
+    console.log(`Pushed tag v${version} to ${remote}`);
+  }
+
+  /**
+   * Get the list of pushed tags (for testing).
+   * @returns {string[]} List of pushed tag names
+   */
+  getPushedTags() {
+    return [...this._pushedTags];
+  }
+
+  /**
+   * Get the number of commits on a branch (for testing).
+   * @param {string} branch - Branch name
+   * @returns {number} Number of commits
+   */
+  getCommitCount(branch) {
+    return this._branches[branch]?.length || 0;
+  }
+
+  /**
+   * Get all branches (for testing).
+   * @returns {string[]} List of branch names
+   */
+  getBranches() {
+    return Object.keys(this._branches);
+  }
+}

package/src/git_real.js

@@ -0,0 +1,210 @@
+/**
+ * Real Git implementation for semver-ratchet.
+ *
+ * This module provides a production implementation of GitAdapter
+ * that executes actual git commands.
+ */
+
+import { execSync } from 'child_process';
+import { GitAdapter } from './git_adapter.js';
+
+/**
+ * Helper function to execute git commands.
+ * @param {string} command - Git command to execute (without 'git' prefix)
+ * @returns {string} Command output
+ * @throws {Error} If command fails
+ */
+function execGit(command) {
+  return execSync(`git ${command}`, { encoding: 'utf-8' }).trim();
+}
+
+/**
+ * Real git implementation that executes actual git commands.
+ *
+ * This is the production implementation used when not testing.
+ */
+export class RealGitAdapter extends GitAdapter {
+  /**
+   * Get the current branch name.
+   * @returns {string} The branch name
+   * @throws {Error} If git operation fails
+   */
+  getCurrentBranch() {
+    try {
+      return execGit('branch --show-current');
+    } catch (error) {
+      throw new Error(`Failed to get current branch: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if current branch is main or master.
+   * @returns {boolean} True if on main/master branch
+   * @throws {Error} If git operation fails
+   */
+  isMainBranch() {
+    const branch = this.getCurrentBranch();
+    return branch.toLowerCase() === 'main' || branch.toLowerCase() === 'master';
+  }
+
+  /**
+   * Calculate the number of commits between HEAD and main branch.
+   * @returns {number} Number of commits
+   * @throws {Error} If git operation fails
+   */
+  getGitDistance() {
+    if (this.isMainBranch()) {
+      return 0;
+    }
+
+    try {
+      // Count commits on current branch not on main
+      this.getCurrentBranch();
+      const output = execGit('rev-list --count HEAD ^origin/main 2>/dev/null || rev-list --count HEAD');
+      return parseInt(output, 10) || 0;
+    } catch {
+      // Fallback: try a simpler approach
+      try {
+        const output = execGit('rev-list --count HEAD');
+        return parseInt(output, 10) || 0;
+      } catch {
+        return 0;
+      }
+    }
+  }
+
+  /**
+   * Get the latest SemVer tag on the current branch.
+   * @returns {string|null} Tag version without 'v' prefix, or null if no tags
+   * @throws {Error} If git operation fails
+   */
+  getLatestTag() {
+    try {
+      const tag = execGit('describe --tags --abbrev=0');
+      // Strip 'v' prefix if present (e.g., "v1.0.0" -> "1.0.0")
+      let version = tag.replace(/^v/, '');
+
+      // Strip pre-release and build metadata if present
+      // e.g., "1.0.0-alpha" -> "1.0.0", "1.0.0+build123" -> "1.0.0"
+      version = version.split(/[-+]/)[0];
+
+      return version;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get commit messages since a specific tag or all commits.
+   * @param {string} [sinceTag] - Optional tag to start from (without 'v' prefix)
+   * @returns {string[]} List of commit messages
+   * @throws {Error} If git operation fails
+   */
+  getCommitMessages(sinceTag = null) {
+    try {
+      let command;
+      if (sinceTag) {
+        command = `log ${sinceTag}..HEAD --pretty=format:%s`;
+      } else {
+        command = 'log --pretty=format:%s -100'; // Get last 100 commits
+      }
+      const output = execGit(command);
+      return output ? output.split('\n').filter(m => m.trim()) : [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Verify that enough git history is available.
+   * @param {number} [fetchDepth=50] - Minimum number of commits required
+   * @returns {boolean} True if sufficient history exists
+   * @throws {Error} If history is insufficient
+   */
+  verifyGitHistory(fetchDepth = 50) {
+    try {
+      // Check if we have enough commits
+      const output = execGit('rev-list --count HEAD');
+      const commitCount = parseInt(output, 10) || 0;
+
+      if (commitCount < fetchDepth) {
+        throw new Error(
+          `Insufficient git history: ${commitCount} commits found, ` +
+          `need at least ${fetchDepth} for accurate version calculation`,
+        );
+      }
+
+      return true;
+    } catch (error) {
+      if (error.message.includes('Insufficient git history')) {
+        throw error;
+      }
+      throw new Error(`Failed to verify git history: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if a tag exists for the given version.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @returns {boolean} True if tag exists
+   * @throws {Error} If git operation fails
+   */
+  tagExists(version) {
+    try {
+      const tagName = `v${version}`;
+      execGit(`rev-parse --verify refs/tags/${tagName} >/dev/null 2>&1`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Create a git tag for the specified version.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @param {boolean} [force=false] - If true, overwrite existing tag
+   * @returns {boolean} True if tag was created successfully
+   * @throws {Error} If git operation fails
+   */
+  createTag(version, force = false) {
+    try {
+      const tagName = `v${version}`;
+
+      if (this.tagExists(version)) {
+        if (force) {
+          // Delete existing tag and create new one
+          execGit(`tag -d ${tagName}`);
+          execGit(`tag -a ${tagName} -m "Release ${version}"`);
+          console.log(`Created tag v${version} (forced)`);
+          return true;
+        } else {
+          console.log(`Tag v${version} already exists. Use --force to overwrite.`);
+          return false;
+        }
+      } else {
+        // Create new tag
+        execGit(`tag -a ${tagName} -m "Release ${version}"`);
+        console.log(`Created tag v${version}`);
+        return true;
+      }
+    } catch (error) {
+      throw new Error(`Failed to create tag: ${error.message}`);
+    }
+  }
+
+  /**
+   * Push a tag to the remote repository.
+   * @param {string} version - Version string (without 'v' prefix)
+   * @param {string} [remote='origin'] - Remote name to push to
+   * @throws {Error} If git operation fails
+   */
+  pushTag(version, remote = 'origin') {
+    try {
+      const tagName = `v${version}`;
+      execSync(`git push ${remote} ${tagName}`, { encoding: 'utf-8' });
+      console.log(`Pushed tag v${version} to ${remote}`);
+    } catch (error) {
+      throw new Error(`Failed to push tag: ${error.message}`);
+    }
+  }
+}