philiprehberger-version_compare 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 45592ec6d8735752e17a9bc545f4fc3d683ee7946bdb3a6ef81f01cbf5e58c12
+  data.tar.gz: 7ac00c790d7da685f6d38e1682738b3df914b2afb7629e9da4950e59523bfa3b
+SHA512:
+  metadata.gz: 968790a6f434c474581d2b2edb07be7136750cdcd94440e208395016ff19b8cf15d1806fe5db93531920812c7b9162b02a44ad2599de8c59e783d6a695bfa1c1
+  data.tar.gz: 1b585e386e5ce18ac64644183004de8d62be3ac362456e456bf140bd8ab9415f0a467fad92369b41aec42d0de2d863b59ae4f9a4254098323851298b369f4d19

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this gem will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-03-22
+
+### Added
+- Initial release
+- SemVer-style version string parsing with major, minor, patch, and pre-release
+- Comparable version objects with full comparison support
+- Constraint matching for >=, <=, >, <, =, !=, and ~> operators
+- Sort and latest helpers for version string arrays

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 philiprehberger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+# philiprehberger-version_compare
+
+[![Tests](https://github.com/philiprehberger/rb-version-compare/actions/workflows/ci.yml/badge.svg)](https://github.com/philiprehberger/rb-version-compare/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/philiprehberger-version_compare.svg)](https://rubygems.org/gems/philiprehberger-version_compare)
+[![License](https://img.shields.io/github/license/philiprehberger/rb-version-compare)](LICENSE)
+
+Version string parsing with comparison, sorting, and constraint matching
+
+## Requirements
+
+- Ruby >= 3.1
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'philiprehberger-version_compare'
+```
+
+Or install directly:
+
+```bash
+gem install philiprehberger-version_compare
+```
+
+## Usage
+
+```ruby
+require 'philiprehberger/version_compare'
+
+v = Philiprehberger::VersionCompare.parse('1.2.3')
+v.major       # => 1
+v.minor       # => 2
+v.patch       # => 3
+v.pre_release # => nil
+```
+
+### Comparison
+
+```ruby
+v1 = Philiprehberger::VersionCompare.parse('1.0.0')
+v2 = Philiprehberger::VersionCompare.parse('2.0.0')
+
+v1 < v2  # => true
+v1 == v2 # => false
+```
+
+### Pre-release Versions
+
+```ruby
+v = Philiprehberger::VersionCompare.parse('1.0.0-beta.1')
+v.pre_release # => "beta.1"
+
+# Release versions are greater than pre-release
+Philiprehberger::VersionCompare.parse('1.0.0') > Philiprehberger::VersionCompare.parse('1.0.0-alpha')
+# => true
+```
+
+### Constraint Matching
+
+```ruby
+v = Philiprehberger::VersionCompare.parse('1.5.3')
+
+v.satisfies?('>= 1.0.0') # => true
+v.satisfies?('< 2.0.0')  # => true
+v.satisfies?('~> 1.5')   # => true
+v.satisfies?('!= 1.0.0') # => true
+```
+
+### Sorting and Latest
+
+```ruby
+versions = ['2.0.0', '1.0.0', '1.5.0', '0.1.0']
+
+Philiprehberger::VersionCompare.sort(versions)
+# => ["0.1.0", "1.0.0", "1.5.0", "2.0.0"]
+
+Philiprehberger::VersionCompare.latest(versions)
+# => "2.0.0"
+```
+
+## API
+
+### `Philiprehberger::VersionCompare`
+
+| Method | Description |
+|--------|-------------|
+| `.parse(str)` | Parse a version string into a `SemanticVersion` |
+| `.sort(versions)` | Sort an array of version strings in ascending order |
+| `.latest(versions)` | Return the highest version string from an array |
+
+### `SemanticVersion`
+
+| Method | Description |
+|--------|-------------|
+| `#major` | Major version number |
+| `#minor` | Minor version number |
+| `#patch` | Patch version number |
+| `#pre_release` | Pre-release identifier or nil |
+| `#satisfies?(constraint)` | Check if version satisfies a constraint (`>=`, `<`, `~>`, `!=`) |
+| `#<=>(other)` | Compare two versions (includes `Comparable`) |
+| `#to_s` | String representation of the version |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lib/philiprehberger/version_compare/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Philiprehberger
+  module VersionCompare
+    VERSION = '0.1.0'
+  end
+end

data/lib/philiprehberger/version_compare.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'version_compare/version'
+
+module Philiprehberger
+  module VersionCompare
+    class Error < StandardError; end
+
+    # A parsed semantic version with comparison support
+    class SemanticVersion
+      include Comparable
+
+      attr_reader :major, :minor, :patch, :pre_release
+
+      # @param major [Integer] major version number
+      # @param minor [Integer] minor version number
+      # @param patch [Integer] patch version number
+      # @param pre_release [String, nil] pre-release identifier
+      def initialize(major, minor, patch, pre_release: nil)
+        @major = major
+        @minor = minor
+        @patch = patch
+        @pre_release = pre_release
+      end
+
+      # Compare two versions following SemVer precedence
+      #
+      # @param other [SemanticVersion] the other version
+      # @return [Integer] -1, 0, or 1
+      def <=>(other)
+        return nil unless other.is_a?(SemanticVersion)
+
+        result = [major, minor, patch] <=> [other.major, other.minor, other.patch]
+        return result unless result.zero?
+
+        compare_pre_release(other)
+      end
+
+      # Check if this version satisfies a constraint string
+      #
+      # @param constraint [String] constraint like ">= 1.0.0", "~> 2.1", "!= 1.2.3", "< 3.0.0"
+      # @return [Boolean] true if the version satisfies the constraint
+      # @raise [Error] if the constraint format is invalid
+      def satisfies?(constraint)
+        operator, version_str = parse_constraint(constraint)
+        other = VersionCompare.parse(version_str)
+
+        case operator
+        when '>='
+          self >= other
+        when '<='
+          self <= other
+        when '>'
+          self > other
+        when '<'
+          self < other
+        when '='
+          self == other
+        when '!='
+          self != other
+        when '~>'
+          pessimistic_match?(other)
+        else
+          raise Error, "unknown operator: #{operator}"
+        end
+      end
+
+      # @return [String] version string representation
+      def to_s
+        base = "#{major}.#{minor}.#{patch}"
+        pre_release ? "#{base}-#{pre_release}" : base
+      end
+
+      def inspect
+        "#<Version #{self}>"
+      end
+
+      private
+
+      def compare_pre_release(other)
+        return 0 if pre_release.nil? && other.pre_release.nil?
+        return 1 if pre_release.nil?
+        return -1 if other.pre_release.nil?
+
+        pre_release <=> other.pre_release
+      end
+
+      def parse_constraint(constraint)
+        match = constraint.strip.match(/\A(>=|<=|~>|!=|>|<|=)?\s*(.+)\z/)
+        raise Error, "invalid constraint: #{constraint}" unless match
+
+        operator = match[1] || '='
+        [operator, match[2].strip]
+      end
+
+      def pessimistic_match?(other)
+        return false if self < other
+
+        if other.patch.zero? && other.minor.zero?
+          major == other.major
+        elsif other.patch.zero?
+          major == other.major && minor == other.minor
+        else
+          major == other.major && minor == other.minor
+        end
+      end
+    end
+
+    # Parse a version string into a SemanticVersion
+    #
+    # @param str [String] version string like "1.2.3" or "1.2.3-beta.1"
+    # @return [SemanticVersion] parsed version
+    # @raise [Error] if the string is not a valid version
+    def self.parse(str)
+      str = str.to_s.strip
+      str = str.sub(/\Av/, '')
+
+      match = str.match(/\A(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-(.+))?\z/)
+      raise Error, "invalid version: #{str}" unless match
+
+      SemanticVersion.new(
+        match[1].to_i,
+        (match[2] || '0').to_i,
+        (match[3] || '0').to_i,
+        pre_release: match[4]
+      )
+    end
+
+    # Sort an array of version strings
+    #
+    # @param versions [Array<String>] version strings to sort
+    # @return [Array<String>] sorted version strings (ascending)
+    def self.sort(versions)
+      versions.sort_by { |v| parse(v) }
+    end
+
+    # Return the latest version from an array of version strings
+    #
+    # @param versions [Array<String>] version strings
+    # @return [String] the latest version string
+    # @raise [Error] if the array is empty
+    def self.latest(versions)
+      raise Error, 'no versions provided' if versions.empty?
+
+      versions.max_by { |v| parse(v) }
+    end
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: philiprehberger-version_compare
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Philip Rehberger
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-22 00:00:00.000000000 Z
+dependencies: []
+description: Parse semantic version strings into comparable objects with support for
+  sorting, finding the latest version, and checking constraint satisfaction.
+email:
+- me@philiprehberger.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/philiprehberger/version_compare.rb
+- lib/philiprehberger/version_compare/version.rb
+homepage: https://github.com/philiprehberger/rb-version-compare
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/philiprehberger/rb-version-compare
+  source_code_uri: https://github.com/philiprehberger/rb-version-compare
+  changelog_uri: https://github.com/philiprehberger/rb-version-compare/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/philiprehberger/rb-version-compare/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Version string parsing with comparison, sorting, and constraint matching
+test_files: []