semver-ratchet 1.0.0

package/src/version.js

@@ -0,0 +1,340 @@
+/**
+ * Version calculation logic for semver-ratchet.
+ *
+ * This module provides the core version calculation functions
+ * that work with both real and mock git adapters.
+ */
+
+import { RealGitAdapter } from './git_real.js';
+import { getManualVersion, getDefaultBump, getVerifyMinDepth } from './config.js';
+
+// Global git adapter instance (can be overridden for testing)
+let _gitAdapter = null;
+
+/**
+ * Get the current git adapter instance.
+ * @returns {GitAdapter} The git adapter
+ */
+function getGitAdapter() {
+  if (!_gitAdapter) {
+    _gitAdapter = new RealGitAdapter();
+  }
+  return _gitAdapter;
+}
+
+/**
+ * Set the git adapter instance (for testing).
+ * @param {GitAdapter} adapter - The git adapter to use
+ */
+export function setGitAdapter(adapter) {
+  _gitAdapter = adapter;
+}
+
+/**
+ * Get the current git adapter (for testing).
+ * @returns {GitAdapter} The git adapter
+ */
+export function getGitAdapterInstance() {
+  return getGitAdapter();
+}
+
+/**
+ * Calculate CRC32 hash of a string as unsigned 32-bit integer.
+ * @param {string} str - Input string
+ * @returns {number} CRC32 hash as unsigned 32-bit integer
+ */
+export function calculateCrc32Unsigned(str) {
+  let crc = 0xFFFFFFFF;
+
+  // Encode string as UTF-8 bytes
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(str);
+
+  // CRC32 polynomial
+  const polynomial = 0xEDB88320;
+
+  for (let i = 0; i < bytes.length; i++) {
+    crc = crc ^ bytes[i];
+    for (let j = 0; j < 8; j++) {
+      if (crc & 1) {
+        crc = (crc >>> 1) ^ polynomial;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+
+  // Return as unsigned 32-bit integer
+  return (crc ^ 0xFFFFFFFF) >>> 0;
+}
+
+/**
+ * Parse a SemVer string into {major, minor, patch} object.
+ * @param {string} version - Version string in format "X.Y.Z"
+ * @returns {{major: number, minor: number, patch: number}}
+ * @throws {Error} If version format is invalid
+ */
+export function parseSemver(version) {
+  // First, strip pre-release and build metadata if present
+  // e.g., "1.0.0-alpha" -> "1.0.0", "1.0.0+build123" -> "1.0.0"
+  const cleanVersion = version.split(/[-+]/)[0];
+
+  // Check for exactly 3 numeric components
+  const parts = cleanVersion.split('.');
+  if (parts.length !== 3) {
+    throw new Error(`Invalid SemVer format: ${version}. Expected X.Y.Z format`);
+  }
+
+  // Check for leading zeros (SemVer 2.0.0 Section 9 violation)
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+
+    // Check if part is empty
+    if (part.length === 0) {
+      throw new Error(`Invalid SemVer format: ${version}. Empty component found`);
+    }
+
+    // Check if part contains only digits
+    if (!/^\d+$/.test(part)) {
+      throw new Error(`Invalid SemVer format: ${version}. Components must be non-negative integers`);
+    }
+
+    // Check for leading zeros (but allow single "0")
+    if (part.length > 1 && part[0] === '0') {
+      throw new Error(`Invalid SemVer format: ${version}. Leading zeros not allowed (SemVer 2.0.0 Section 9)`);
+    }
+  }
+
+  return {
+    major: parseInt(parts[0], 10),
+    minor: parseInt(parts[1], 10),
+    patch: parseInt(parts[2], 10),
+  };
+}
+
+/**
+ * Compare two SemVer versions.
+ * @param {string} v1 - First version
+ * @param {string} v2 - Second version
+ * @returns {number} -1 if v1 < v2, 0 if equal, 1 if v1 > v2
+ */
+export function compareSemver(v1, v2) {
+  const { major: m1, minor: n1, patch: p1 } = parseSemver(v1);
+  const { major: m2, minor: n2, patch: p2 } = parseSemver(v2);
+
+  if (m1 !== m2) return m1 < m2 ? -1 : 1;
+  if (n1 !== n2) return n1 < n2 ? -1 : 1;
+  if (p1 !== p2) return p1 < p2 ? -1 : 1;
+  return 0;
+}
+
+/**
+ * Generate a list of compatible version strings for dependency pinning.
+ * For a version like 4.3.1, returns: ["4.3.1", "4.3", "4"]
+ * @param {string} version - Full version string in SemVer format
+ * @returns {string[]} List of compatible version strings
+ * @throws {Error} If version format is invalid
+ */
+export function getCompatibleVersions(version) {
+  const { major, minor, patch } = parseSemver(version);
+
+  return [
+    `${major}.${minor}.${patch}`, // Full version
+    `${major}.${minor}`,          // Major.minor (for ^ pinning)
+    `${major}`,                    // Major only (for ~ pinning)
+  ];
+}
+
+/**
+ * Check if current branch is main or master.
+ * @returns {boolean} True if on main/master branch
+ */
+export function isMainBranch() {
+  return getGitAdapter().isMainBranch();
+}
+
+/**
+ * Get the current branch name.
+ * @returns {string} The branch name
+ */
+export function getCurrentBranch() {
+  return getGitAdapter().getCurrentBranch();
+}
+
+/**
+ * Determine the version bump type from commit messages.
+ * @param {string[]} messages - List of commit messages
+ * @param {string} [defaultBump='patch'] - Default bump type if no tags found
+ * @returns {string} 'major', 'minor', or 'patch'
+ * @throws {Error} If defaultBump is invalid
+ */
+export function determineVersionBump(messages, defaultBump = 'patch') {
+  const validDefaults = ['major', 'minor', 'patch'];
+  if (!validDefaults.includes(defaultBump.toLowerCase())) {
+    throw new Error(`Invalid defaultBump: ${defaultBump}. Must be one of: ${validDefaults.join(', ')}`);
+  }
+
+  // Check for explicit tags (case-insensitive)
+  for (const message of messages) {
+    const upperMessage = message.toUpperCase();
+    if (upperMessage.includes('[MAJOR]')) {
+      return 'major';
+    }
+  }
+
+  for (const message of messages) {
+    const upperMessage = message.toUpperCase();
+    if (upperMessage.includes('[MINOR]')) {
+      return 'minor';
+    }
+  }
+
+  for (const message of messages) {
+    const upperMessage = message.toUpperCase();
+    if (upperMessage.includes('[PATCH]')) {
+      return 'patch';
+    }
+  }
+
+  // Return default if no explicit tags found
+  return defaultBump.toLowerCase();
+}
+
+/**
+ * Calculate the main branch version based on tags and commits.
+ * @param {string} defaultBump - Default bump type (major|minor|patch)
+ * @param {boolean} verifyHistory - Whether to verify git history
+ * @returns {string} SemVer version string
+ * @throws {Error} If on feature branch or git operations fail
+ */
+export function calculateMainVersion(defaultBump = 'patch', verifyHistory = true) {
+  const adapter = getGitAdapter();
+
+  // Verify we're on main branch
+  if (!adapter.isMainBranch()) {
+    throw new Error('Cannot calculate main version on feature branch');
+  }
+
+  // Verify git history if requested
+  if (verifyHistory) {
+    try {
+      adapter.verifyGitHistory(getVerifyMinDepth());
+    } catch {
+      // History verification failed, but we can still calculate version
+      // Just use the latest tag or default
+    }
+  }
+
+  // Get the latest tag
+  const latestTag = adapter.getLatestTag();
+
+  if (!latestTag) {
+    // No tags yet, start at 1.0.0
+    return '1.0.0';
+  }
+
+  // Parse the latest version
+  const { major, minor, patch } = parseSemver(latestTag);
+
+  // Get commit messages since the latest tag
+  const commitMessages = adapter.getCommitMessages(latestTag);
+
+  // Determine the bump type
+  const bumpType = determineVersionBump(commitMessages, defaultBump);
+
+  // Calculate new version
+  switch (bumpType) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+    default:
+      return `${major}.${minor}.${patch + 1}`;
+  }
+}
+
+/**
+ * Calculate the feature branch version.
+ * @param {string} _defaultBump - Default bump type (not used for feature branches)
+ * @param {boolean} _verifyHistory - Whether to verify git history
+ * @returns {string} Feature version string (0.{CRC}.{Distance})
+ * @throws {Error} If on main branch
+ */
+export function calculateFeatureVersion(_defaultBump = 'patch', _verifyHistory = true) {
+  const adapter = getGitAdapter();
+
+  // Verify we're NOT on main branch
+  if (adapter.isMainBranch()) {
+    throw new Error('Cannot calculate feature version on main branch');
+  }
+
+  const branchName = adapter.getCurrentBranch();
+  const crc = calculateCrc32Unsigned(branchName);
+  const distance = adapter.getGitDistance();
+
+  return `0.${crc}.${distance}`;
+}
+
+/**
+ * Get the current version based on git state.
+ * @param {string} [defaultBump] - Default bump type for main branch (uses env/config if not provided)
+ * @param {boolean} [verifyHistory=true] - Whether to verify git history
+ * @returns {string} Version string
+ */
+export function getVersion(defaultBump, _verifyHistory = true) {
+  // Check for manual version override first
+  const manualVersion = getManualVersion();
+  if (manualVersion !== undefined) {
+    return manualVersion;
+  }
+
+  // Use config default if not provided
+  if (defaultBump === undefined) {
+    defaultBump = getDefaultBump();
+  }
+
+  const adapter = getGitAdapter();
+
+  if (adapter.isMainBranch()) {
+    return calculateMainVersion(defaultBump, _verifyHistory);
+  } else {
+    return calculateFeatureVersion(defaultBump, _verifyHistory);
+  }
+}
+
+/**
+ * Verify git history is sufficient.
+ * @param {number} [fetchDepth=50] - Minimum number of commits required
+ * @throws {Error} If history is insufficient
+ */
+export function verifyGitHistory(fetchDepth = 50) {
+  getGitAdapter().verifyGitHistory(fetchDepth);
+}
+
+/**
+ * Create a git tag for the current version.
+ * @param {string} [defaultBump='patch'] - Default bump type
+ * @param {boolean} _force - Whether to overwrite existing tag
+ * @returns {boolean} True if tag was created
+ */
+export function createGitTag(defaultBump = 'patch', _force = false) {
+  const adapter = getGitAdapter();
+
+  if (!adapter.isMainBranch()) {
+    throw new Error('Git tags can only be created on main branch');
+  }
+
+  const version = getVersion(defaultBump, false);
+  return adapter.createTag(version, _force);
+}
+
+/**
+ * Push a git tag to remote.
+ * @param {string} _version - Version string to push (without 'v' prefix)
+ * @param {string} [remote='origin'] - Remote name
+ */
+export function pushGitTag(_version, remote = 'origin') {
+  const adapter = getGitAdapter();
+  adapter.pushTag(_version, remote);
+}