Implement sbt version and requirement classes (#14871)

* implement sbt version and requirement classes

* bump sorbet typing to strong in version class

* add sbt version pattern and reference it

Author: AbhishekBhaskar

sbt/lib/dependabot/sbt/requirement.rb

@@ -1,25 +1,61 @@
-# typed: strong
+# typed: strict
 # frozen_string_literal: true
 
-# NOTE: This file was scaffolded automatically but is OPTIONAL.
-# If your ecosystem uses standard Gem::Requirement logic,
-# you can safely delete this file and remove the require from lib/dependabot/sbt.rb
+require "sorbet-runtime"
 
 require "dependabot/requirement"
 require "dependabot/utils"
+require "dependabot/maven/shared/shared_requirement"
+require "dependabot/sbt/version"
 
 module Dependabot
   module Sbt
-    class Requirement < Dependabot::Requirement
+    # SBT typically uses exact versions ("org" % "artifact" % "1.2.3"),
+    # but Maven-style version ranges are valid since artifacts resolve
+    # from Maven repositories.
+    class Requirement < Dependabot::Maven::Shared::SharedRequirement
       extend T::Sig
 
-      sig do
-        override
-          .params(requirement_string: T.nilable(String))
-          .returns(T::Array[Dependabot::Requirement])
+      quoted = OPS.keys.map { |k| Regexp.quote k }.join("|")
+      PATTERN_RAW = T.let("\\s*(#{quoted})?\\s*(#{Sbt::Version::VERSION_PATTERN})\\s*".freeze, String)
+      PATTERN = T.let(/\A#{PATTERN_RAW}\z/, Regexp)
+      RUBY_STYLE_PATTERN = T.let(/\A\s*(#{quoted})\s*(#{Sbt::Version::VERSION_PATTERN})\s*\z/, Regexp)
+
+      sig { override.returns(Regexp) }
+      def self.pattern
+        PATTERN
+      end
+
+      sig { override.returns(Regexp) }
+      def self.ruby_style_pattern
+        RUBY_STYLE_PATTERN
       end
+
+      sig { override.params(obj: T.any(Gem::Version, String)).returns([String, Gem::Version]) }
+      def self.parse(obj)
+        return ["=", Sbt::Version.new(obj.to_s)] if obj.is_a?(Gem::Version)
+
+        unless (matches = PATTERN.match(obj.to_s))
+          msg = "Illformed requirement [#{obj.inspect}]"
+          raise BadRequirementError, msg
+        end
+
+        return DefaultRequirement if matches[1] == ">=" && matches[2] == "0"
+
+        [matches[1] || "=", Sbt::Version.new(T.must(matches[2]))]
+      end
+
+      sig { override.params(requirement_string: T.nilable(String)).returns(T::Array[Requirement]) }
       def self.requirements_array(requirement_string)
-        [new(requirement_string)]
+        split_java_requirement(requirement_string).map do |str|
+          new(str)
+        end
+      end
+
+      sig { override.params(version: Gem::Version).returns(T::Boolean) }
+      def satisfied_by?(version)
+        version = Sbt::Version.new(version.to_s)
+        super
       end
     end
   end

sbt/lib/dependabot/sbt/version.rb

@@ -1,21 +1,19 @@
 # typed: strong
 # frozen_string_literal: true
 
-# NOTE: This file was scaffolded automatically but is OPTIONAL.
-# If your ecosystem uses standard semantic versioning without special logic,
-# you can safely delete this file and remove the require from lib/dependabot/sbt.rb
+require "sorbet-runtime"
 
-require "dependabot/version"
+require "dependabot/maven/version"
 require "dependabot/utils"
 
 module Dependabot
   module Sbt
-    class Version < Dependabot::Version
+    # SBT resolves artifacts from Maven repositories and uses the same
+    # version ordering specification as Maven.
+    class Version < Dependabot::Maven::Version
       extend T::Sig
 
-      # TODO: Implement custom version comparison logic if needed
-      # Example: Handle pre-release versions, build metadata, etc.
-      # If standard semantic versioning is sufficient, delete this file
+      VERSION_PATTERN = T.let(Dependabot::Maven::Version::VERSION_PATTERN, String)
     end
   end
 end

sbt/spec/dependabot/sbt/requirement_spec.rb

@@ -0,0 +1,122 @@
+# typed: false
+# frozen_string_literal: true
+
+require "spec_helper"
+require "dependabot/sbt/requirement"
+require "dependabot/sbt/version"
+
+RSpec.describe Dependabot::Sbt::Requirement do
+  subject(:requirement) { described_class.new(requirement_string) }
+
+  let(:requirement_string) { ">=1.0.0" }
+
+  describe ".new" do
+    subject(:requirement) { described_class.new(requirement_string) }
+
+    context "with an exact version (typical SBT usage)" do
+      let(:requirement_string) { "1.0.0" }
+
+      it { is_expected.to eq(Gem::Requirement.new("= 1.0.0")) }
+    end
+
+    context "with a pre-release version" do
+      let(:requirement_string) { "1.3.alpha" }
+
+      it { is_expected.to be_satisfied_by(Gem::Version.new("1.3.alpha")) }
+    end
+
+    context "with a range requirement" do
+      let(:requirement_string) { "[1.0.0,)" }
+
+      it { is_expected.to eq(Gem::Requirement.new(">= 1.0.0")) }
+
+      context "when needing a > operator" do
+        let(:requirement_string) { "(1.0.0,)" }
+
+        it { is_expected.to eq(Gem::Requirement.new("> 1.0.0")) }
+      end
+
+      context "when needing a > and a < operator" do
+        let(:requirement_string) { "(1.0.0, 2.0.0)" }
+
+        it { is_expected.to eq(Gem::Requirement.new("> 1.0.0", "< 2.0.0")) }
+      end
+
+      context "when needing a >= and a <= operator" do
+        let(:requirement_string) { "[1.0.0, 2.0.0]" }
+
+        it { is_expected.to eq(Gem::Requirement.new(">= 1.0.0", "<= 2.0.0")) }
+      end
+    end
+
+    context "with a soft requirement" do
+      let(:requirement_string) { "[1.0.0]" }
+
+      it "treats it as an equality matcher" do
+        expect(requirement).to be_satisfied_by(
+          Dependabot::Sbt::Version.new("1.0.0")
+        )
+      end
+    end
+
+    context "with a wildcard version ending in +" do
+      let(:requirement_string) { "1.0.+" }
+
+      it "converts to a pessimistic constraint" do
+        expect(requirement).to be_satisfied_by(Dependabot::Sbt::Version.new("1.0.1"))
+        expect(requirement).to be_satisfied_by(Dependabot::Sbt::Version.new("1.0.9"))
+        expect(requirement).not_to be_satisfied_by(Dependabot::Sbt::Version.new("1.1.0"))
+      end
+    end
+
+    context "with a bare wildcard +" do
+      let(:requirement_string) { "+" }
+
+      it "matches any version" do
+        expect(requirement).to be_satisfied_by(Dependabot::Sbt::Version.new("1.0.0"))
+        expect(requirement).to be_satisfied_by(Dependabot::Sbt::Version.new("99.0.0"))
+      end
+    end
+  end
+
+  describe ".requirements_array" do
+    subject(:requirements) { described_class.requirements_array(requirement_string) }
+
+    context "with a single requirement" do
+      let(:requirement_string) { "1.0.0" }
+
+      it "returns an array with one equality requirement" do
+        expect(requirements.length).to eq(1)
+        expect(requirements.first).to eq(Gem::Requirement.new("= 1.0.0"))
+      end
+    end
+
+    context "with multiple OR requirements" do
+      let(:requirement_string) { "[1.0,2.0),(3.0,4.0)" }
+
+      it "returns an array with the correct split requirements" do
+        expect(requirements.length).to eq(2)
+        expect(requirements.first).to eq(Gem::Requirement.new(">= 1.0", "< 2.0"))
+        expect(requirements.last).to eq(Gem::Requirement.new("> 3.0", "< 4.0"))
+      end
+    end
+  end
+
+  describe "#satisfied_by?" do
+    subject { requirement.satisfied_by?(version) }
+
+    let(:requirement_string) { ">=1.0.0" }
+
+    context "with a version that satisfies the requirement" do
+      let(:version) { Dependabot::Sbt::Version.new("1.5.0") }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a version that does not satisfy the requirement" do
+      let(:version) { Dependabot::Sbt::Version.new("0.9.0") }
+
+      it { is_expected.to be(false) }
+    end
+  end
+end

sbt/spec/dependabot/sbt/version_spec.rb

@@ -0,0 +1,106 @@
+# typed: false
+# frozen_string_literal: true
+
+require "spec_helper"
+require "dependabot/sbt/version"
+
+RSpec.describe Dependabot::Sbt::Version do
+  subject(:version) { described_class.new(version_string) }
+
+  let(:version_string) { "1.0.0" }
+
+  describe ".correct?" do
+    subject { described_class.correct?(version_string) }
+
+    context "with a normal version" do
+      let(:version_string) { "1.0.0" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a named version" do
+      let(:version_string) { "Finchley" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a dynamic version" do
+      let(:version_string) { "1.+" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a nil version" do
+      let(:version_string) { nil }
+
+      it { is_expected.to be(false) }
+    end
+
+    context "with an empty version" do
+      let(:version_string) { "" }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "#to_s" do
+    subject { version.to_s }
+
+    context "with no dashes" do
+      let(:version_string) { "1.0.0" }
+
+      it { is_expected.to eq("1.0.0") }
+    end
+
+    context "with a dash-specified prerelease" do
+      let(:version_string) { "1.0.0-rc1" }
+
+      it { is_expected.to eq("1.0.0-rc1") }
+    end
+
+    context "with underscores" do
+      let(:version_string) { "1.0_2" }
+
+      it { is_expected.to eq("1.0_2") }
+    end
+  end
+
+  describe "#prerelease?" do
+    subject { version.prerelease? }
+
+    context "with an alpha version" do
+      let(:version_string) { "1.0.0-alpha" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with an RC version" do
+      let(:version_string) { "1.0.0-rc1" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a SNAPSHOT version" do
+      let(:version_string) { "1.0.0-SNAPSHOT" }
+
+      it { is_expected.to be(true) }
+    end
+
+    context "with a stable version" do
+      let(:version_string) { "1.0.0" }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "comparison" do
+    context "when comparing to another version" do
+      it "orders correctly" do
+        expect(described_class.new("1.0.0")).to be < described_class.new("1.0.1")
+        expect(described_class.new("1.0.0")).to be < described_class.new("2.0.0")
+        expect(described_class.new("1.0.0-alpha")).to be < described_class.new("1.0.0")
+        expect(described_class.new("1.0.0-SNAPSHOT")).to be < described_class.new("1.0.0")
+      end
+    end
+  end
+end