Add Detected Version to Base Version Manager and Update Ecosystem Package Managers and Languages

bundler/lib/dependabot/bundler/language.rb

@@ -14,7 +14,10 @@ class Language < Dependabot::Ecosystem::VersionManager
 
       sig { params(raw_version: String, requirement: T.nilable(Requirement)).void }
       def initialize(raw_version, requirement = nil)
-        super(LANGUAGE, Version.new(raw_version), [], [], requirement)
+        super(
+          name: LANGUAGE,
+          version: Version.new(raw_version),
+          requirement: requirement)
       end
     end
   end

bundler/lib/dependabot/bundler/package_manager.rb

@@ -31,11 +31,11 @@ class PackageManager < Dependabot::Ecosystem::VersionManager
       end
       def initialize(raw_version, requirement = nil)
         super(
-          PACKAGE_MANAGER,
-          Version.new(raw_version),
-          DEPRECATED_BUNDLER_VERSIONS,
-          SUPPORTED_BUNDLER_VERSIONS,
-          requirement,
+          name: PACKAGE_MANAGER,
+          version: Version.new(raw_version),
+          deprecated_versions: DEPRECATED_BUNDLER_VERSIONS,
+          supported_versions: SUPPORTED_BUNDLER_VERSIONS,
+          requirement: requirement,
        )
       end
     end

cargo/lib/dependabot/cargo/language.rb

@@ -15,8 +15,8 @@ class Language < Dependabot::Ecosystem::VersionManager
       sig { params(raw_version: String).void }
       def initialize(raw_version)
         super(
-          LANGUAGE,
-          Version.new(raw_version)
+          name: LANGUAGE,
+          version: Version.new(raw_version)
         )
       end
     end

cargo/lib/dependabot/cargo/package_manager.rb

@@ -20,10 +20,10 @@ class PackageManager < Dependabot::Ecosystem::VersionManager
       sig { params(raw_version: String).void }
       def initialize(raw_version)
         super(
-          PACKAGE_MANAGER,
-          Version.new(raw_version),
-          DEPRECATED_CARGO_VERSIONS,
-          SUPPORTED_CARGO_VERSIONS
+          name: PACKAGE_MANAGER,
+          version: Version.new(raw_version),
+          deprecated_versions: DEPRECATED_CARGO_VERSIONS,
+          supported_versions: SUPPORTED_CARGO_VERSIONS
         )
       end
 

common/lib/dependabot/ecosystem.rb

@@ -17,30 +17,38 @@ class VersionManager
       abstract!
       # Initialize version information for a package manager or language.
       # @param name [String] the name of the package manager or language (e.g., "bundler", "ruby").
-      # @param version [Dependabot::Version] the parsed current version.
+      # @param detected_version [Dependabot::Version] the detected version of the package manager or language.
+      # @param version [Dependabot::Version] the version dependabots run on.
       # @param deprecated_versions [Array<Dependabot::Version>] an array of deprecated versions.
       # @param supported_versions [Array<Dependabot::Version>] an array of supported versions.
       # @param requirement [Dependabot::Requirement] an array of requirements.
       # @example
-      #   VersionManager.new("bundler", "2.1.4", nil)
+      #   VersionManager.new(
+      #   name: "bundler",
+      #   version: Version.new("2.1.4"),
+      #   requirement: nil
+      # )
       sig do
         params(
           name: String,
-          version: Dependabot::Version,
+          detected_version: T.nilable(Dependabot::Version),
+          version: T.nilable(Dependabot::Version),
           deprecated_versions: T::Array[Dependabot::Version],
           supported_versions: T::Array[Dependabot::Version],
           requirement: T.nilable(Dependabot::Requirement)
         ).void
       end
       def initialize(
-        name,
-        version,
-        deprecated_versions = [],
-        supported_versions = [],
-        requirement = nil
+        name:,
+        detected_version: nil,
+        version: nil,
+        deprecated_versions: [],
+        supported_versions: [],
+        requirement: nil
       )
         @name = T.let(name, String)
-        @version = T.let(version, Dependabot::Version)
+        @detected_version = T.let(detected_version || version, T.nilable(Dependabot::Version))
+        @version = T.let(version, T.nilable(Dependabot::Version))
         @deprecated_versions = T.let(deprecated_versions, T::Array[Dependabot::Version])
         @supported_versions = T.let(supported_versions, T::Array[Dependabot::Version])
         @requirement = T.let(requirement, T.nilable(Dependabot::Requirement))
@@ -52,10 +60,16 @@ def initialize(
       sig { returns(String) }
       attr_reader :name
 
+      # The current version of the package manager or language.
+      # @example
+      #   detected_version #=> Dependabot::Version.new("2")
+      sig { returns(T.nilable(Dependabot::Version)) }
+      attr_reader :detected_version
+
       # The current version of the package manager or language.
       # @example
       #   version #=> Dependabot::Version.new("2.1.4")
-      sig { returns(Dependabot::Version) }
+      sig { returns(T.nilable(Dependabot::Version)) }
       attr_reader :version
 
       # Returns an array of deprecated versions of the package manager.
@@ -82,35 +96,41 @@ def initialize(
       #   deprecated? #=> true
       sig { returns(T::Boolean) }
       def deprecated?
+        return false unless detected_version
+
         # If the version is unsupported, the unsupported error is getting raised separately.
         return false if unsupported?
 
-        deprecated_versions.include?(version)
+        deprecated_versions.include?(detected_version)
       end
 
       # Checks if the current version is unsupported.
       # @example
       #   unsupported? #=> false
       sig { returns(T::Boolean) }
       def unsupported?
+        return false unless detected_version
+
         return false if supported_versions.empty?
 
         # Check if the version is not supported
-        supported_versions.all? { |supported| supported > version }
+        supported_versions.all? { |supported| supported > detected_version }
       end
 
       # Raises an error if the current package manager or language version is unsupported.
       # If the version is unsupported, it raises a ToolVersionNotSupported error.
       sig { void }
       def raise_if_unsupported!
+        return unless detected_version
+
         return unless unsupported?
 
         # Example: v2.*, v3.*
         supported_versions_message = supported_versions.map { |v| "v#{v}.*" }.join(", ")
 
         raise ToolVersionNotSupported.new(
           name,
-          version.to_s,
+          detected_version.to_s,
           supported_versions_message
         )
       end

common/lib/dependabot/notices.rb

@@ -112,7 +112,7 @@ def self.generate_pm_deprecation_notice(package_manager)
       )
       notice_type = "#{package_manager.name}_deprecated_warn"
       title = "Package manager deprecation notice"
-      description = "Dependabot will stop supporting `#{package_manager.name} v#{package_manager.version}`!"
+      description = "Dependabot will stop supporting `#{package_manager.name} v#{package_manager.detected_version}`!"
 
       ## Add the supported versions to the description
       description += "\n\n#{supported_versions_description}\n" unless supported_versions_description.empty?

common/spec/dependabot/ecosystem_spec.rb

@@ -13,35 +13,44 @@
   let(:deprecated_versions) { [Dependabot::Version.new("1")] }
   let(:requirement) { TestRequirement.new(">= 1.0") }
 
+  let(:package_manager_detected_version) { "1.0.0" }
   let(:package_manager_raw_version) { "1.0.0" }
+  let(:language_detected_version) { "3.0.0" }
   let(:language_raw_version) { "3.0.0" }
 
   let(:package_manager) do
     Class.new(Dependabot::Ecosystem::VersionManager) do
-      def initialize(raw_version, deprecated_versions, supported_versions, requirement)
+      def initialize(detected_version, raw_version, deprecated_versions, supported_versions, requirement)
         super(
-          "bundler", # name
-          Dependabot::Version.new(raw_version), # version
-          deprecated_versions, # deprecated_versions
-          supported_versions, # supported_versions
-          requirement # requirement
+          name: "bundler", # name
+          detected_version: Dependabot::Version.new(detected_version), # version
+          version: Dependabot::Version.new(raw_version), # version
+          deprecated_versions: deprecated_versions, # deprecated_versions
+          supported_versions: supported_versions, # supported_versions
+          requirement: requirement # requirement
         )
       end
-    end.new(package_manager_raw_version, deprecated_versions, supported_versions, requirement)
+    end.new(
+      package_manager_detected_version,
+      package_manager_raw_version,
+      deprecated_versions,
+      supported_versions,
+      requirement
+    )
   end
 
   let(:language) do
     Class.new(Dependabot::Ecosystem::VersionManager) do
-      def initialize(raw_version)
+      def initialize(detected_version, raw_version)
         super(
-          "ruby", # name
-          Dependabot::Version.new(raw_version), # version
-          [], # deprecated_versions
-          [], # supported_versions
-          nil # requirement
+          name: "ruby", # name
+          detected_version: Dependabot::Version.new(detected_version), # version
+          version: Dependabot::Version.new(raw_version), # version
+          deprecated_versions: [], # deprecated_versions
+          supported_versions: [], # supported_versions
         )
       end
-    end.new(language_raw_version)
+    end.new(language_detected_version, language_raw_version)
   end
 
   describe "#initialize" do
@@ -56,6 +65,7 @@ def initialize(raw_version)
 
   describe "#deprecated?" do
     context "when the package manager version is deprecated" do
+      let(:package_manager_detected_version) { "1" }
       let(:package_manager_raw_version) { "1" }
 
       it "returns true" do
@@ -65,6 +75,7 @@ def initialize(raw_version)
     end
 
     context "when the package manager version is not deprecated" do
+      let(:package_manager_detected_version) { "2.0.0" }
       let(:package_manager_raw_version) { "2.0.0" }
 
       it "returns false" do
@@ -76,6 +87,7 @@ def initialize(raw_version)
 
   describe "#unsupported?" do
     context "when the package manager version is unsupported" do
+      let(:package_manager_detected_version) { "0.8.0" }
       let(:package_manager_raw_version) { "0.8.0" }
 
       it "returns true" do
@@ -85,6 +97,7 @@ def initialize(raw_version)
     end
 
     context "when the package manager version is supported" do
+      let(:package_manager_detected_version) { "2.0.0" }
       let(:package_manager_raw_version) { "2.0.0" }
 
       it "returns false" do
@@ -96,6 +109,7 @@ def initialize(raw_version)
 
   describe "#raise_if_unsupported!" do
     context "when the package manager version is unsupported" do
+      let(:package_manager_detected_version) { "0.8.0" }
       let(:package_manager_raw_version) { "0.8.0" }
 
       it "raises a ToolVersionNotSupported error" do
@@ -105,6 +119,7 @@ def initialize(raw_version)
     end
 
     context "when the package manager version is supported" do
+      let(:package_manager_detected_version) { "2.0.0" }
       let(:package_manager_raw_version) { "2.0.0" }
 
       it "does not raise an error" do

common/spec/dependabot/file_parsers/base_spec.rb

@@ -50,10 +50,10 @@
       def initialize
         raw_version = "1.0.0"
         super(
-          "bundler", # name
-          Dependabot::Version.new(raw_version), # version
-          [Dependabot::Version.new("1.0.0")], # deprecated_versions
-          [Dependabot::Version.new("1.1.0"), Dependabot::Version.new("2.0.0")] # supported_versions
+          name: "bundler", # name
+          version: Dependabot::Version.new(raw_version), # version
+          deprecated_versions: [Dependabot::Version.new("1.0.0")], # deprecated_versions
+          supported_versions: [Dependabot::Version.new("1.1.0"), Dependabot::Version.new("2.0.0")] # supported_versions
         )
       end
 

common/spec/dependabot/notices_spec.rb

@@ -8,14 +8,15 @@
 
 # A stub package manager for testing purposes.
 class StubPackageManager < Dependabot::Ecosystem::VersionManager
-  def initialize(name:, version:, deprecated_versions: [], supported_versions: [],
+  def initialize(name:, detected_version:, raw_version:, deprecated_versions: [], supported_versions: [],
                  support_later_versions: false)
     @support_later_versions = support_later_versions
     super(
-      name,
-     Dependabot::Version.new(version),
-     deprecated_versions,
-     supported_versions
+      name: name,
+      detected_version: Dependabot::Version.new(detected_version),
+      version: Dependabot::Version.new(raw_version),
+      deprecated_versions: deprecated_versions,
+      supported_versions: supported_versions
    )
   end
 
@@ -113,7 +114,8 @@ def support_later_versions?
     let(:package_manager) do
       StubPackageManager.new(
         name: "bundler",
-        version: Dependabot::Version.new("1"),
+        detected_version: Dependabot::Version.new("1"),
+        raw_version: Dependabot::Version.new("1.0.0"),
         deprecated_versions: [Dependabot::Version.new("1")],
         supported_versions: [Dependabot::Version.new("2"), Dependabot::Version.new("3")]
       )

common/spec/dependabot/version_manager_spec.rb

@@ -8,12 +8,14 @@
   let(:concrete_class) do
     Class.new(Dependabot::Ecosystem::VersionManager) do
       def initialize
+        detected_version = "1.0.0"
         raw_version = "1.0.0"
         super(
-          "bundler", # name
-          Dependabot::Version.new(raw_version), # version
-          [Dependabot::Version.new("1")], # deprecated_versions
-          [Dependabot::Version.new("1"), Dependabot::Version.new("2")] # supported_versions
+          name: "bundler", # name
+          detected_version: Dependabot::Version.new(detected_version), # version
+          version: Dependabot::Version.new(raw_version), # version
+          deprecated_versions: [Dependabot::Version.new("1")], # deprecated_versions
+          supported_versions: [Dependabot::Version.new("1"), Dependabot::Version.new("2")] # supported_versions
         )
       end
 
@@ -26,10 +28,12 @@ def support_later_versions?
   let(:default_concrete_class) do
     Class.new(Dependabot::Ecosystem::VersionManager) do
       def initialize
+        detected_version = "1.0.0"
         raw_version = "1.0.0"
         super(
-          "bundler", # name
-          Dependabot::Version.new(raw_version)
+          name: "bundler", # name
+          detected_version: Dependabot::Version.new(detected_version),
+          version: Dependabot::Version.new(raw_version)
         )
       end
     end
@@ -90,10 +94,12 @@ def initialize
     end
 
     context "when version is unsupported" do
-      let(:version) { Dependabot::Version.new("0.9.0") }
+      let(:detected_version) { Dependabot::Version.new("0.9") }
+      let(:raw_version) { Dependabot::Version.new("0.9.0") }
 
       it "returns false as unsupported takes precedence" do
-        package_manager.instance_variable_set(:@version, version)
+        package_manager.instance_variable_set(:@detected_version, detected_version)
+        package_manager.instance_variable_set(:@version, raw_version)
         package_manager.instance_variable_set(:@supported_versions,
                                               [Dependabot::Version.new("1"), Dependabot::Version.new("2")])
         expect(package_manager.deprecated?).to be false
@@ -103,10 +109,12 @@ def initialize
 
   describe "#unsupported?" do
     context "when version is unsupported" do
-      let(:version) { Dependabot::Version.new("0.9.0") }
+      let(:detected_version) { Dependabot::Version.new("0.9") }
+      let(:raw_version) { Dependabot::Version.new("0.9.0") }
 
       it "returns true" do
-        package_manager.instance_variable_set(:@version, version)
+        package_manager.instance_variable_set(:@detected_version, detected_version)
+        package_manager.instance_variable_set(:@version, raw_version)
         package_manager.instance_variable_set(:@supported_versions,
                                               [Dependabot::Version.new("1"), Dependabot::Version.new("2")])
         expect(package_manager.unsupported?).to be true