dependabot-rust_toolchain 0.321.2

data/lib/dependabot/rust_toolchain/requirement.rb

@@ -0,0 +1,233 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "dependabot/requirement"
+require "dependabot/utils"
+
+require "dependabot/rust_toolchain"
+require "dependabot/rust_toolchain/version"
+require "dependabot/rust_toolchain/channel_parser"
+require "dependabot/rust_toolchain/channel_type"
+
+module Dependabot
+  module RustToolchain
+    class Requirement < Dependabot::Requirement
+      # For consistency with other languages, we define a requirements array.
+      # rust-toolchain always contains a single element.
+      sig { override.params(requirement_string: T.nilable(String)).returns(T::Array[Dependabot::Requirement]) }
+      def self.requirements_array(requirement_string)
+        [new(requirement_string)]
+      end
+
+      sig do
+        params(obj: T.any(String, Gem::Version)).returns(T::Array[T.any(String, Dependabot::RustToolchain::Version)])
+      end
+      def self.parse(obj)
+        return ["=", RustToolchain::Version.new(obj.to_s)] if obj.is_a?(Gem::Version)
+
+        requirement_string = obj.to_s.strip
+
+        # Parse requirement strings with operators (e.g., ">= 1.72.0")
+        match = requirement_string.match(/^(>=|>|<=|<|=)\s?(.+)$/)
+        if match
+          operator = T.must(match[1])
+          version_string = T.must(match[2]).strip
+
+          # Special case: handle ">= 0" which is used to represent "all versions"
+          return [operator, RustToolchain::Version.new("0.0.0")] if version_string == "0"
+
+          # Validate the version string
+          if RustToolchain::Version.correct?(version_string)
+            return [operator, RustToolchain::Version.new(version_string)]
+          end
+        end
+
+        # Handle bare version strings (no operator)
+        if requirement_string == "0"
+          # Special case: handle bare "0" as "0.0.0"
+          return ["=", RustToolchain::Version.new("0.0.0")]
+        end
+
+        if RustToolchain::Version.correct?(requirement_string)
+          return ["=", RustToolchain::Version.new(requirement_string)]
+        end
+
+        # If it's not a valid Rust toolchain format, fall back to default
+        msg = "Illformed requirement [#{obj.inspect}]"
+        raise BadRequirementError, msg
+      end
+
+      # Patches Gem::Requirement to make it accept requirement strings like
+      # "~> 4.2.5, >= 4.2.5.1" without first needing to split them.
+      sig { params(requirements: T.nilable(String)).void }
+      def initialize(*requirements)
+        requirements = requirements.flatten.flat_map do |req_string|
+          req_string&.split(",")&.map(&:strip)
+        end.compact
+
+        super(requirements)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      sig { override.params(version: T.any(Gem::Version, String)).returns(T::Boolean) }
+      def satisfied_by?(version)
+        version = RustToolchain::Version.new(version.to_s) unless version.is_a?(RustToolchain::Version)
+
+        T.cast(requirements, T::Array[T::Array[T.untyped]]).all? do |req|
+          op = T.cast(req[0], String)
+          rv = T.cast(req[1], RustToolchain::Version)
+
+          case op
+          when "="
+            satisfy_exact_requirement?(version, rv)
+          when ">="
+            satisfy_greater_than_or_equal_requirement?(version, rv)
+          when ">"
+            satisfy_greater_than_requirement?(version, rv)
+          when "<="
+            satisfy_less_than_or_equal_requirement?(version, rv)
+          when "<"
+            satisfy_less_than_requirement?(version, rv)
+          else
+            # Fall back to default behavior for other operators
+            ops_method = T.let(OPS[op], T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean)))
+            ops_method ||= T.cast(OPS["="], T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
+            ops_method.call(version, rv)
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      private
+
+      # Check if version satisfies exact requirement
+      sig { params(version: RustToolchain::Version, requirement_version: RustToolchain::Version).returns(T::Boolean) }
+      def satisfy_exact_requirement?(version, requirement_version)
+        return version == requirement_version if version.channel.nil? || requirement_version.channel.nil?
+
+        v_channel = T.must(version.channel)
+        r_channel = T.must(requirement_version.channel)
+
+        # Channels must be of the same type and equal
+        v_channel.channel_type == r_channel.channel_type && v_channel == r_channel
+      end
+
+      # Check if version satisfies >= requirement
+      sig { params(version: RustToolchain::Version, requirement_version: RustToolchain::Version).returns(T::Boolean) }
+      def satisfy_greater_than_or_equal_requirement?(version, requirement_version)
+        return version >= requirement_version if version.channel.nil? || requirement_version.channel.nil?
+
+        v_channel = T.must(version.channel)
+        r_channel = T.must(requirement_version.channel)
+
+        # Can only compare channels of the same type
+        return false unless v_channel.channel_type == r_channel.channel_type
+
+        case v_channel.channel_type
+        when ChannelType::Version
+          # Compare semantic versions
+          v_channel >= r_channel
+        when ChannelType::DatedStability
+          # Must be same stability level to compare dates
+          return false unless v_channel.stability == r_channel.stability
+
+          v_channel >= r_channel
+        when ChannelType::Stability
+          # Stability channels can be ordered: stable > beta > nightly
+          stability_order(v_channel.stability) >= stability_order(r_channel.stability)
+        else
+          false
+        end
+      end
+
+      # Check if version satisfies > requirement
+      sig { params(version: RustToolchain::Version, requirement_version: RustToolchain::Version).returns(T::Boolean) }
+      def satisfy_greater_than_requirement?(version, requirement_version)
+        return version > requirement_version if version.channel.nil? || requirement_version.channel.nil?
+
+        v_channel = T.must(version.channel)
+        r_channel = T.must(requirement_version.channel)
+
+        # Can only compare channels of the same type
+        return false unless v_channel.channel_type == r_channel.channel_type
+
+        case v_channel.channel_type
+        when ChannelType::Version
+          v_channel > r_channel
+        when ChannelType::DatedStability
+          return false unless v_channel.stability == r_channel.stability
+
+          v_channel > r_channel
+        when ChannelType::Stability
+          stability_order(v_channel.stability) > stability_order(r_channel.stability)
+        else
+          false
+        end
+      end
+
+      # Check if version satisfies <= requirement
+      sig { params(version: RustToolchain::Version, requirement_version: RustToolchain::Version).returns(T::Boolean) }
+      def satisfy_less_than_or_equal_requirement?(version, requirement_version)
+        return version <= requirement_version if version.channel.nil? || requirement_version.channel.nil?
+
+        v_channel = T.must(version.channel)
+        r_channel = T.must(requirement_version.channel)
+
+        # Can only compare channels of the same type
+        return false unless v_channel.channel_type == r_channel.channel_type
+
+        case v_channel.channel_type
+        when ChannelType::Version
+          v_channel <= r_channel
+        when ChannelType::DatedStability
+          return false unless v_channel.stability == r_channel.stability
+
+          v_channel <= r_channel
+        when ChannelType::Stability
+          stability_order(v_channel.stability) <= stability_order(r_channel.stability)
+        else
+          false
+        end
+      end
+
+      # Check if version satisfies < requirement
+      sig { params(version: RustToolchain::Version, requirement_version: RustToolchain::Version).returns(T::Boolean) }
+      def satisfy_less_than_requirement?(version, requirement_version)
+        return version < requirement_version if version.channel.nil? || requirement_version.channel.nil?
+
+        v_channel = T.must(version.channel)
+        r_channel = T.must(requirement_version.channel)
+
+        # Can only compare channels of the same type
+        return false unless v_channel.channel_type == r_channel.channel_type
+
+        case v_channel.channel_type
+        when ChannelType::Version
+          v_channel < r_channel
+        when ChannelType::DatedStability
+          return false unless v_channel.stability == r_channel.stability
+
+          v_channel < r_channel
+        when ChannelType::Stability
+          stability_order(v_channel.stability) < stability_order(r_channel.stability)
+        else
+          false
+        end
+      end
+
+      # Define stability ordering for comparison
+      # stable (3) > beta (2) > nightly (1)
+      sig { params(stability: T.nilable(String)).returns(Integer) }
+      def stability_order(stability)
+        case stability
+        when STABLE_CHANNEL then 3
+        when BETA_CHANNEL then 2
+        when NIGHTLY_CHANNEL then 1
+        else 0
+        end
+      end
+    end
+  end
+end
+
+Dependabot::Utils.register_requirement_class("rust_toolchain", Dependabot::RustToolchain::Requirement)

data/lib/dependabot/rust_toolchain/update_checker/latest_version_finder.rb

@@ -0,0 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require "dependabot/update_checkers/base"
+require "dependabot/package/package_latest_version_finder"
+
+require "dependabot/rust_toolchain/channel_type"
+require "dependabot/rust_toolchain/package/package_details_fetcher"
+require "dependabot/rust_toolchain/version"
+
+module Dependabot
+  module RustToolchain
+    class UpdateChecker < Dependabot::UpdateCheckers::Base
+      class LatestVersionFinder < Dependabot::Package::PackageLatestVersionFinder
+        extend T::Sig
+
+        sig { override.returns(T.nilable(Dependabot::Package::PackageDetails)) }
+        def package_details
+          @package_details ||= Dependabot::RustToolchain::Package::PackageDetailsFetcher.new(
+            dependency: dependency
+          ).fetch
+        end
+
+        protected
+
+        sig do
+          override
+            .params(releases: T::Array[Dependabot::Package::PackageRelease])
+            .returns(T::Array[Dependabot::Package::PackageRelease])
+        end
+        def apply_post_fetch_latest_versions_filter(releases)
+          filter_by_version_type(releases)
+        end
+
+        sig do
+          override
+            .params(releases: T::Array[Dependabot::Package::PackageRelease])
+            .returns(T::Array[Dependabot::Package::PackageRelease])
+        end
+        def apply_post_fetch_lowest_security_fix_versions_filter(releases)
+          filter_by_version_type(releases)
+        end
+
+        sig { override.returns(T::Boolean) }
+        def cooldown_enabled?
+          Dependabot::Experiments.enabled?(:enable_cooldown_for_rust_toolchain)
+        end
+
+        private
+
+        sig do
+          params(releases: T::Array[Dependabot::Package::PackageRelease])
+            .returns(T::Array[Dependabot::Package::PackageRelease])
+        end
+        def filter_by_version_type(releases)
+          current_version = T.cast(dependency.numeric_version, T.nilable(Dependabot::RustToolchain::Version))
+          return [] unless current_version
+
+          current_channel = current_version.channel
+          return [] unless current_channel
+
+          current_type = current_channel.channel_type
+
+          # There are no updates for channels
+          # i.e. "stable", "beta", "nightly"
+          return [] if current_type == ChannelType::Stability
+
+          is_current_major_minor = major_minor_format?(current_version.to_s)
+
+          channel_matched_releases = releases.filter_map do |release|
+            release_rust_version = T.cast(release.version, Dependabot::RustToolchain::Version)
+            release_channel = release_rust_version.channel
+            next unless release_channel
+
+            # Check that the release version is in the same channel type
+            next unless release_channel.channel_type == current_type
+
+            next release unless release_channel.channel_type == ChannelType::Version
+
+            # For version channels, we need to ensure that the version format matches
+            is_release_major_minor = major_minor_format?(release_rust_version.to_s)
+            case [is_current_major_minor, is_release_major_minor]
+            in [true, true] | [false, false]
+              release
+            else
+              nil
+            end
+          end
+
+          channel_matched_releases.uniq do |release|
+            release.version.to_s
+          end
+        end
+
+        # Check if a version string is in major.minor format (e.g., "1.72" vs "1.72.0")
+        sig { params(version_string: String).returns(T::Boolean) }
+        def major_minor_format?(version_string)
+          version_string.count(".") == 1
+        end
+      end
+    end
+  end
+end

data/lib/dependabot/rust_toolchain/update_checker.rb

@@ -0,0 +1,75 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require "dependabot/errors"
+require "dependabot/update_checkers"
+require "dependabot/update_checkers/base"
+
+module Dependabot
+  module RustToolchain
+    class UpdateChecker < Dependabot::UpdateCheckers::Base
+      extend T::Sig
+
+      require_relative "update_checker/latest_version_finder"
+
+      sig { override.returns(T.nilable(T.any(String, Gem::Version))) }
+      def latest_version
+        latest_version_finder.latest_version
+      end
+
+      sig { override.returns(T.nilable(T.any(String, Gem::Version))) }
+      def latest_resolvable_version
+        latest_version
+      end
+
+      sig { override.returns(T.nilable(Dependabot::Version)) }
+      def latest_resolvable_version_with_no_unlock
+        raise NotImplementedError
+      end
+
+      sig { override.returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+      def updated_requirements
+        dependency.requirements.map do |requirement|
+          {
+            file: requirement[:file],
+            requirement: latest_version,
+            groups: requirement[:groups],
+            source: requirement[:source]
+          }
+        end
+      end
+
+      private
+
+      sig { override.returns(T::Boolean) }
+      def latest_version_resolvable_with_full_unlock?
+        false
+      end
+
+      sig { override.returns(T::Array[Dependabot::Dependency]) }
+      def updated_dependencies_after_full_unlock
+        raise NotImplementedError
+      end
+
+      sig { returns(LatestVersionFinder) }
+      def latest_version_finder
+        @latest_version_finder ||= T.let(
+          LatestVersionFinder.new(
+            dependency: dependency,
+            dependency_files: dependency_files,
+            credentials: credentials,
+            ignored_versions: ignored_versions,
+            security_advisories: security_advisories,
+            cooldown_options: update_cooldown,
+            raise_on_ignored: raise_on_ignored
+          ),
+          T.nilable(LatestVersionFinder)
+        )
+      end
+    end
+  end
+end
+
+Dependabot::UpdateCheckers.register("rust_toolchain", Dependabot::RustToolchain::UpdateChecker)

data/lib/dependabot/rust_toolchain/version.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "dependabot/version"
+require "dependabot/utils"
+
+require "dependabot/rust_toolchain/channel_parser"
+require "dependabot/rust_toolchain/channel_type"
+
+module Dependabot
+  module RustToolchain
+    class Version < Dependabot::Version
+      sig { override.params(version: VersionParameter).void }
+      def initialize(version)
+        raise BadRequirementError, "Malformed channel string - string is nil" if version.nil?
+
+        @version_string = T.let(version.to_s.strip, String)
+        @channel = T.let(
+          Dependabot::RustToolchain::ChannelParser.new(@version_string).parse,
+          T.nilable(Dependabot::RustToolchain::Channel)
+        )
+
+        super(@version_string)
+      end
+
+      sig { override.params(version: VersionParameter).returns(Dependabot::RustToolchain::Version) }
+      def self.new(version)
+        T.cast(super, Dependabot::RustToolchain::Version)
+      end
+
+      sig { override.params(version: VersionParameter).returns(T::Boolean) }
+      def self.correct?(version)
+        return false if version.to_s.empty?
+
+        !Dependabot::RustToolchain::ChannelParser.new(version.to_s).parse.nil?
+      rescue ArgumentError
+        Dependabot.logger.info("Malformed version string #{version}")
+        false
+      end
+
+      sig { override.returns(String) }
+      def to_s
+        return "" if @channel.nil?
+
+        case @channel.channel_type
+        in ChannelType::Version
+          T.must(@channel.version)
+        in ChannelType::DatedStability
+          "#{@channel.stability}-#{@channel.date}"
+        in ChannelType::Stability
+          T.must(@channel.stability)
+        else
+          ""
+        end
+      end
+
+      sig { returns(T.nilable(Dependabot::RustToolchain::Channel)) }
+      attr_reader :channel
+    end
+  end
+end
+
+Dependabot::Utils
+  .register_version_class("rust_toolchain", Dependabot::RustToolchain::Version)

data/lib/dependabot/rust_toolchain.rb

@@ -0,0 +1,42 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "dependabot/rust_toolchain/file_fetcher"
+require "dependabot/rust_toolchain/file_parser"
+require "dependabot/rust_toolchain/update_checker"
+require "dependabot/rust_toolchain/file_updater"
+require "dependabot/rust_toolchain/metadata_finder"
+require "dependabot/rust_toolchain/requirement"
+require "dependabot/rust_toolchain/version"
+
+require "dependabot/pull_request_creator/labeler"
+Dependabot::PullRequestCreator::Labeler
+  .register_label_details("rust_toolchain", name: "rust_toolchain_package_manager", colour: "D34516")
+
+require "dependabot/dependency"
+Dependabot::Dependency
+  .register_production_check("rust_toolchain", ->(_) { true })
+
+module Dependabot
+  module RustToolchain
+    RUST_TOOLCHAIN_TOML_FILENAME = "rust-toolchain.toml"
+
+    RUST_TOOLCHAIN_FILENAME = "rust-toolchain"
+
+    STABLE_CHANNEL = "stable"
+
+    BETA_CHANNEL = "beta"
+
+    NIGHTLY_CHANNEL = "nightly"
+
+    RUST_GITHUB_URL = "https://github.com/rust-lang/rust"
+
+    ECOSYSTEM = "rust"
+
+    PACKAGE_MANAGER = "rustup"
+
+    SUPPORTED_VERSIONS = T.let([].freeze, T::Array[Dependabot::Version])
+
+    DEPRECATED_VERSIONS = T.let([].freeze, T::Array[Dependabot::Version])
+  end
+end