semver_dialects 3.2.1 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 485026a6d305008958423bb059e470b3d8c5561a6cecc1e0cb33c562df01e255
-  data.tar.gz: b9ff4d4852dbdc5a7d6356b7d4bc9691c2c3e38ba9bbd8220e1169a53b8100b7
+  metadata.gz: 9358b5e27d5e1128e133c3ea3fc04bfdce8d35d8db3479a8edb367eba5d5b766
+  data.tar.gz: 334101a02b1af9ab5368ec7003c02d344d3f0e45294c107cda841da3b5e40c86
 SHA512:
-  metadata.gz: 29500b37adb16288fbd88e504f7b631a2137b36a0cf5a3b544662bef93f8272fdea9d7a16a637d5c9000e95f860b101149f3885185dfdf26a8e506a8763af4e3
-  data.tar.gz: 784199112df64433895f31b1a9dc0a9c73b0097d331be26fa3a1d112398e1cdc554d43bc9007b875e3e6d08f687c3e73e8e45323a48404ff59f869a04e5d19a8
+  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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SemverDialects
-  VERSION = '3.2.1'
+  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.1
+  version: 3.3.0
 platform: ruby
 authors:
 - Julian Thome
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-02 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