semver_dialects 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bb0072ff97d5e5cfa0fbc45bc12d7e62c05fac187e88df2020e8c084bdf6b4b
-  data.tar.gz: a0274b8b83ea7cbdf008f3257f5423cebbbc6ce2bcd17e57f0dff62b78126902
+  metadata.gz: 9358b5e27d5e1128e133c3ea3fc04bfdce8d35d8db3479a8edb367eba5d5b766
+  data.tar.gz: 334101a02b1af9ab5368ec7003c02d344d3f0e45294c107cda841da3b5e40c86
 SHA512:
-  metadata.gz: 15764e9e3ebdfb5857f6b66d634b4bdecfb0d17eea886c10b150628be4210bd9309c3ef831bb58eb4ea40879094e8a28bf20af74e6cd7ba99a29a30705f92c4f
-  data.tar.gz: 43ee2d405325b327928dea45c0b4463e61878563525930f65c5efc17b8310a4e370cee6366b5d022a6126a47f9fce9f1b30ef7b66a1e6778de3e23f5e80823b7
+  metadata.gz: 94af1e53527c2b56ab22c0792bc085d9c594abd1a5285aa73d8b968cfee761566967d7b093aaa10353d79c684fec71f6ed3edf83f55e37cf02a054f7dcaa4c41
+  data.tar.gz: c4aefce6856543bae0aca7cc07f706b023ee9d345f3a18c2d68b3178be4f781963a32de3d75cdf179f2d9549985d217a8dc00c4588a0e0c35b4391eae3efaea6

data/lib/semver_dialects/apk.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'strscan'
+
+module SemverDialects
+  module Apk
+    # This implementation references the version.c apk-tools implementation
+    # https://gitlab.alpinelinux.org/alpine/apk-tools/-/blob/6052bfef57a81d82451b4cad86f78a2d01959767/src/version.c
+    # apk version spec can be found here https://wiki.alpinelinux.org/wiki/APKBUILD_Reference#pkgver
+    class Version < BaseVersion
+      PRE_RELEASE_ORDER = { 'alpha' => 0, 'beta' => 1, 'pre' => 2, 'rc' => 3 }.freeze
+      POST_RELEASE_ORDER = { 'cvs' => 0, 'svn' => 1, 'git' => 2, 'hg' => 3, 'p' => 4 }.freeze
+
+      attr_reader :tokens, :pre_release, :post_release, :revision
+
+      def initialize(tokens, pre_release: [], post_release: [], revision: [])
+        @tokens = tokens
+        @pre_release = pre_release
+        @post_release = post_release
+        @revision = revision
+      end
+
+      def <=>(other)
+        cmp = compare_tokens(tokens, other.tokens)
+        return cmp unless cmp.zero?
+
+        cmp = compare_pre_release(pre_release, other.pre_release)
+        return cmp unless cmp.zero?
+
+        cmp = compare_post_release(post_release, other.post_release)
+        return cmp unless cmp.zero?
+
+        compare_revisions(revision, other.revision)
+      end
+
+      # Note that to_s does not accurately recreate the version string
+      # if alphabets are present in the version segment.
+      # For instance 1.2.a or 1.2a would both be returned as 1.2.a with to_s
+      # More details in https://gitlab.com/gitlab-org/ruby/gems/semver_dialects/-/merge_requests/97#note_1989192447
+      def to_s
+        @to_s ||= begin
+          main = tokens.join('.')
+          main += "_#{pre_release.join('')}" unless pre_release.empty?
+          main += "_#{post_release.join('')}" unless post_release.empty?
+          main += "-#{revision.join('')}" unless revision.empty?
+          main
+        end
+      end
+
+      private
+
+      # Token can be either integer or string
+      # Precedence: numeric token > string token > no token
+      def compare_token_pair(a, b)
+        return 1 if !a.nil? && b.nil?
+        return -1 if a.nil? && !b.nil?
+
+        return 1 if a.is_a?(Integer) && b.is_a?(String)
+        return -1 if a.is_a?(String) && b.is_a?(Integer)
+
+        # Remaining scenario are tokens of the same type ie Integer or String. Use <=> to compare
+        a <=> b
+      end
+
+      # Precedence: post-release > no release > pre-release
+      # https://wiki.alpinelinux.org/wiki/APKBUILD_Reference#pkgver
+      def compare_pre_release(a, b)
+        return 0 if a.empty? && b.empty?
+        return -1 if !a.empty? && b.empty?
+        return 1 if a.empty? && !b.empty?
+
+        compare_suffix(a, b, PRE_RELEASE_ORDER)
+      end
+
+      # Precedence: post-release > no release > pre-release
+      # https://wiki.alpinelinux.org/wiki/APKBUILD_Reference#pkgver
+      def compare_post_release(a, b)
+        return 0 if a.empty? && b.empty?
+        return 1 if !a.empty? && b.empty?
+        return -1 if a.empty? && !b.empty?
+
+        compare_suffix(a, b, POST_RELEASE_ORDER)
+      end
+
+      # Pre-release precedence: alpha < beta < pre < rc
+      # Post-release precedence: cvs < svn < git < hg < p
+      # Precedence for releases with number eg alpha1:
+      # release without number < release with number
+      def compare_suffix(a, b, order)
+        a_suffix = order[a[0]]
+        b_suffix = order[b[0]]
+
+        return 1 if a_suffix > b_suffix
+        return -1 if a_suffix < b_suffix
+
+        a_value = a[1]
+        b_value = b[1]
+
+        return 1 if !a_value.nil? && b_value.nil?
+        return -1 if a_value.nil? && !b_value.nil?
+
+        (a_value || 0) <=> (b_value || 0)
+      end
+
+      def compare_revisions(a, b)
+        return 0 if a.empty? && b.empty?
+        return 1 if !a.empty? && b.empty?
+        return -1 if a.empty? && !b.empty?
+
+        a_value = a[1]
+        b_value = b[1]
+
+        return 1 if !a_value.nil? && b_value.nil?
+        return -1 if a_value.nil? && !b_value.nil?
+
+        (a_value || 0) <=> (b_value || 0)
+      end
+    end
+
+    class VersionParser
+      DASH = /-/
+      ALPHABETS = /([a-zA-Z]+)/
+      DIGITS = /([0-9]+)/
+      DIGIT = /[0-9]/
+      DOT = '.'
+      UNDERSCORE = '_'
+      PRE_RELEASE_SUFFIXES = %w[alpha beta pre rc].freeze
+      POST_RELEASE_SUFFIXES = %w[cvs svn git hg p].freeze
+      WHITE_SPACE = /\s/
+
+      def self.parse(input)
+        new(input).parse
+      end
+
+      attr_reader :scanner, :input
+
+      def initialize(input)
+        @input = input
+        @pre_release = []
+        @post_release = []
+        @revision = []
+        @scanner = StringScanner.new(input)
+      end
+
+      # Parse splits the raw version string into:
+      # version, pre_release, post_release and revision
+      # Format: <version>_<release>-<revision>
+      # Note that version segment can contain alphabets
+      # Release is always preceded with `_`
+      # Revision is always preceded with `-`
+      def parse
+        tokens = parse_tokens
+
+        Version.new(tokens, pre_release: @pre_release, post_release: @post_release, revision: @revision)
+      end
+
+      private
+
+      def parse_tokens
+        tokens = []
+
+        until scanner.eos?
+          case
+          when (s = scanner.scan(ALPHABETS))
+            tokens << s
+          when (s = scanner.scan(DIGITS))
+            # TODO: add support to parse numbers with leading zero https://gitlab.com/gitlab-org/gitlab/-/issues/471509
+            raise SemverDialects::UnsupportedVersionError, input if s.start_with?('0') && s.length > 1
+
+            tokens << s.to_i
+          when (s = scanner.scan(UNDERSCORE))
+            parse_release
+            # Continue parsing if there's remaining tokens since revision which comes after release is optional
+            return tokens if scanner.eos?
+          when (s = scanner.scan(DASH))
+            parse_revision
+            return tokens
+          when (s = scanner.scan(WHITE_SPACE))
+            # Raise error if there's whitespace
+            raise SemverDialects::InvalidVersionError, input
+          when (s = scanner.scan(DOT))
+            # Skip parsing dot
+          else
+            raise SemverDialects::IncompleteScanError, scanner.rest
+          end
+        end
+        tokens
+      end
+
+      # PRE_RELEASE_SUFFIXES: alpha, beta, pre, rc
+      # POST_RELEASE_SUFFIXES: cvs, svn, git, hg, p
+      # No other suffixes are allowed
+      # Release can be either `<suffix>` or `<suffix><number>` with the number being optional
+      def parse_release
+        # TODO: Add support to parse version with multiple releases
+        raise SemverDialects::UnsupportedVersionError, input if !@pre_release.empty? || !@post_release.empty?
+
+        suffix_type = nil
+        until scanner.eos?
+          case
+          when (s = scanner.scan(ALPHABETS))
+            if PRE_RELEASE_SUFFIXES.include?(s)
+              suffix_type = :pre
+              @pre_release << s
+            elsif POST_RELEASE_SUFFIXES.include?(s)
+              suffix_type = :post
+              @post_release << s
+            else
+              raise SemverDialects::InvalidVersionError, input
+            end
+            return unless scanner.peek(1) =~ DIGIT
+          when (s = scanner.scan(DIGITS))
+            if suffix_type == :pre
+              @pre_release << s.to_i
+              return
+            elsif suffix_type == :post
+              @post_release << s.to_i
+              return
+            end
+          end
+        end
+      end
+
+      # Revision can be either `r` or `r<number>` with the number being optional
+      def parse_revision
+        until scanner.eos?
+          case
+          when (s = scanner.scan(ALPHABETS))
+            raise SemverDialects::InvalidVersionError, input unless s == 'r'
+
+            @revision << s
+
+            return unless scanner.peek(1) =~ DIGIT
+          when (s = scanner.scan(DIGITS))
+            @revision << s.to_i
+            return
+          end
+        end
+      end
+    end
+  end
+end

data/lib/semver_dialects/rpm.rb

@@ -86,43 +86,43 @@ module SemverDialects
       TILDE = /~/
       DIGIT = /([0-9]+)/
       COLON = /:/
-      NON_ALPHANUMERIC_DASH_AND_TILDE = /[^a-zA-Z0-9~]+/
+      NON_ALPHANUMERIC_DASH_TILDE_AND_WHITESPACE = /[^a-zA-Z0-9~\s]+/
+      WHITE_SPACE = /\s/
 
       def self.parse(input)
         new(input).parse
       end
-    
+
       def initialize(input)
+        @input = input
         @scanner = StringScanner.new(input)
       end
-      
+
       # parse splits the input string into epoch, version and release tag Eg: <epoch>:<version>-<release_tag>
       # The version and release tag are split at the first `-` character if present
       # With the segment before the first `-` being version while the other being release tag
       # Subsequent `-` are disregarded
       def parse
         epoch = nil
-        if s = scanner.scan(/\d+:/)
+        if (s = scanner.scan(/\d+:/))
           epoch = s[..-2].to_i
         end
 
         # parse tokens until we reach the release tag, if any
         tokens = parse_tokens(false)
-        
+
         # parse release tag
         release_tag = nil
-        if scanner.rest?
-          release_tag = ReleaseTag.new(parse_tokens(true))
-        end
+        release_tag = ReleaseTag.new(parse_tokens(true)) if scanner.rest?
 
         raise IncompleteScanError, scanner.rest if scanner.rest?
-        
+
         Version.new(tokens, epoch: epoch, release_tag: release_tag)
       end
-    
+
       private
-    
-      attr_reader :scanner
+
+      attr_reader :scanner, :input
 
       def parse_tokens(stop_at_release_tag)
         tokens = []
@@ -130,9 +130,7 @@ module SemverDialects
         until scanner.eos?
           case
           when (s = scanner.scan(DASH))
-            if !stop_at_release_tag
-              return tokens
-            end
+            return tokens unless stop_at_release_tag
             # If release tag has been encountered, ignore subsequent dashes
           when (s = scanner.scan(ALPHABET))
             tokens << s
@@ -140,7 +138,11 @@ module SemverDialects
             tokens << s
           when (s = scanner.scan(DIGIT))
             tokens << s.to_i
-          when (s = scanner.scan(NON_ALPHANUMERIC_DASH_AND_TILDE))
+          when (s = scanner.scan(WHITE_SPACE))
+            # Whitespace is not permitted
+            # https://github.com/rpm-software-management/rpm/blob/4d1b7401415003720ea9bef7bda248f7de4fa025/docs/manual/dependencies.md#versioning
+            raise SemverDialects::InvalidVersionError, input
+          when (s = scanner.scan(NON_ALPHANUMERIC_DASH_TILDE_AND_WHITESPACE))
             # Non-ascii characters are considered equal
             # so they are ignored when parsing versions
             # https://github.com/rpm-software-management/rpm/blob/rpm-4.19.1.1-release/tests/rpmvercmp.at#L143
@@ -151,6 +153,5 @@ module SemverDialects
         tokens
       end
     end
-    
   end
 end

data/lib/semver_dialects/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SemverDialects
-  VERSION = '3.2.0'
+  VERSION = '3.3.0'
 end

data/lib/semver_dialects.rb

@@ -4,6 +4,7 @@ require 'semver_dialects/version'
 require 'semver_dialects/base_version'
 require 'semver_dialects/maven'
 require 'semver_dialects/rpm'
+require 'semver_dialects/apk'
 require 'semver_dialects/semver2'
 require 'semver_dialects/semantic_version'
 require 'semver_dialects/boundary'
@@ -28,6 +29,16 @@ module SemverDialects
     end
   end
 
+  class UnsupportedVersionError < Error
+    def initialize(raw_version)
+      @raw_version = raw_version
+    end
+
+    def message
+      "unsupported version '#{@raw_version}'"
+    end
+  end
+
   class InvalidVersionError < Error
     def initialize(raw_version)
       @raw_version = raw_version
@@ -86,7 +97,7 @@ module SemverDialects
   end
 
   def self.os_pkg_version_satisfies?(typ, raw_ver, raw_constraint)
-    return unless %w[deb rpm].include?(typ)
+    return unless %w[deb rpm apk].include?(typ)
     # we only support the less than operator, because that's the only one currently output
     # by the advisory exporter for operating system packages.
     raise SemverDialects::InvalidConstraintError, raw_constraint unless raw_constraint[0] == '<'
@@ -101,6 +112,11 @@ module SemverDialects
       v1 = Rpm::VersionParser.parse(raw_ver)
       v2 = Rpm::VersionParser.parse(raw_constraint[1..])
 
+      v1 < v2
+    when 'apk'
+      v1 = Apk::VersionParser.parse(raw_ver)
+      v2 = Apk::VersionParser.parse(raw_constraint[1..])
+
       v1 < v2
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semver_dialects
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Julian Thome
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-26 00:00:00.000000000 Z
+date: 2024-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pastel
@@ -177,6 +177,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/semver_dialects.rb
+- lib/semver_dialects/apk.rb
 - lib/semver_dialects/base_version.rb
 - lib/semver_dialects/boundary.rb
 - lib/semver_dialects/cli.rb