dependabot-core 0.81.1 → 0.82.0

data/lib/dependabot/update_checkers/elm/elm_package/elm_19_version_resolver.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require "dependabot/shared_helpers"
-require "dependabot/errors"
-require "dependabot/file_parsers/elm/elm_package"
-require "dependabot/update_checkers/elm/elm_package"
-require "dependabot/update_checkers/elm/elm_package/cli_parser"
-require "dependabot/update_checkers/elm/elm_package/requirements_updater"
-require "dependabot/utils/elm/requirement"
-
-module Dependabot
-  module UpdateCheckers
-    module Elm
-      class ElmPackage
-        class Elm19VersionResolver
-          class UnrecoverableState < StandardError; end
-
-          def initialize(dependency:, dependency_files:)
-            @dependency = dependency
-            @dependency_files = dependency_files
-          end
-
-          def latest_resolvable_version(unlock_requirement:)
-            unless %i(none own all).include?(unlock_requirement)
-              raise "Invalid unlock setting: #{unlock_requirement}"
-            end
-
-            # Elm has no lockfile, so we will never create an update PR if
-            # unlock requirements are `none`. Just return the current version.
-            return current_version if unlock_requirement == :none
-
-            # Otherwise, we gotta check a few conditions to see if bumping
-            # wouldn't also bump other deps in elm-package.json
-            fetch_latest_resolvable_version(unlock_requirement)
-          end
-
-          def updated_dependencies_after_full_unlock
-            changed_deps = install_metadata
-
-            original_dependency_details.map do |original_dep|
-              new_version = changed_deps.fetch(original_dep.name, nil)
-              next unless new_version
-
-              old_reqs = original_dep.requirements.map do |req|
-                requirement_class.new(req[:requirement])
-              end
-
-              next if old_reqs.all? { |req| req.satisfied_by?(new_version) }
-
-              new_requirements =
-                RequirementsUpdater.new(
-                  requirements: original_dep.requirements,
-                  latest_resolvable_version: new_version.to_s
-                ).updated_requirements
-
-              Dependency.new(
-                name: original_dep.name,
-                version: new_version.to_s,
-                requirements: new_requirements,
-                previous_version: original_dep.version,
-                previous_requirements: original_dep.requirements,
-                package_manager: original_dep.package_manager
-              )
-            end.compact
-          end
-
-          private
-
-          attr_reader :dependency, :dependency_files
-
-          def fetch_latest_resolvable_version(unlock_requirement)
-            changed_deps = install_metadata
-
-            result = check_install_result(changed_deps)
-            version_after_install = changed_deps.fetch(dependency.name)
-
-            # If the install was clean then we can definitely update
-            return version_after_install if result == :clean_bump
-
-            # Otherwise, we can still update if the result was a forced full
-            # unlock and we're allowed to unlock other requirements
-            return version_after_install if unlock_requirement == :all
-
-            current_version
-          end
-
-          def check_install_result(changed_deps)
-            other_deps_bumped =
-              changed_deps.
-              keys.
-              reject { |name| name == dependency.name }
-
-            return :forced_full_unlock_bump if other_deps_bumped.any?
-
-            :clean_bump
-          end
-
-          def install_metadata
-            @install_metadata ||=
-              SharedHelpers.in_a_temporary_directory do
-                write_temporary_dependency_files
-
-                # Elm package install outputs a preview of the actions to be
-                # performed. We can use this preview to calculate whether it
-                # would do anything funny
-                command = "yes n | elm19 install #{dependency.name}"
-                response = run_shell_command(command)
-
-                CliParser.decode_install_preview(response)
-              rescue SharedHelpers::HelperSubprocessFailed => error
-                # 5) We bump our dep but elm blows up
-                handle_elm_errors(error)
-              end
-          end
-
-          def run_shell_command(command)
-            raw_response = nil
-            IO.popen(command, err: %i(child out)) do |process|
-              raw_response = process.read
-            end
-
-            # Raise an error with the output from the shell session if Elm
-            # returns a non-zero status
-            return raw_response if $CHILD_STATUS.success?
-
-            raise SharedHelpers::HelperSubprocessFailed.new(
-              raw_response,
-              command
-            )
-          end
-
-          def handle_elm_errors(error)
-            if error.message.include?("OLD DEPENDENCIES") ||
-               error.message.include?("BAD JSON")
-              raise Dependabot::DependencyFileNotResolvable, error.message
-            end
-
-            # Raise any unrecognised errors
-            raise error
-          end
-
-          def write_temporary_dependency_files
-            dependency_files.each do |file|
-              path = file.name
-              FileUtils.mkdir_p(Pathname.new(path).dirname)
-
-              File.write(path, updated_elm_json_content(file.content))
-            end
-          end
-
-          def updated_elm_json_content(content)
-            json = JSON.parse(content)
-
-            # Delete the dependency from the elm.json, so that we can use
-            # `elm install <dependency_name>` to generate the install plan
-            %w(dependencies test-dependencies).each do |type|
-              if json.dig(type, dependency.name)
-                json[type].delete(dependency.name)
-              end
-
-              %w(direct indirect).each do |category|
-                if json.dig(type, category, dependency.name)
-                  json[type][category].delete(dependency.name)
-                end
-              end
-            end
-
-            json["source-directories"] = []
-
-            JSON.dump(json)
-          end
-
-          def original_dependency_details
-            @original_dependency_details ||=
-              FileParsers::Elm::ElmPackage.new(
-                dependency_files: dependency_files,
-                source: nil
-              ).parse
-          end
-
-          def current_version
-            return unless dependency.version
-
-            version_class.new(dependency.version)
-          end
-
-          def version_class
-            Utils::Elm::Version
-          end
-
-          def requirement_class
-            Utils::Elm::Requirement
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dependabot/update_checkers/elm/elm_package/requirements_updater.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require "dependabot/utils/elm/version"
-require "dependabot/utils/elm/requirement"
-require "dependabot/update_checkers/elm/elm_package"
-
-module Dependabot
-  module UpdateCheckers
-    module Elm
-      class ElmPackage
-        class RequirementsUpdater
-          RANGE_REQUIREMENT_REGEX =
-            /(\d+\.\d+\.\d+) <= v < (\d+\.\d+\.\d+)/.freeze
-          SINGLE_VERSION_REGEX = /\A(\d+\.\d+\.\d+)\z/.freeze
-
-          def initialize(requirements:, latest_resolvable_version:)
-            @requirements = requirements
-
-            return unless latest_resolvable_version
-            return unless version_class.correct?(latest_resolvable_version)
-
-            @latest_resolvable_version =
-              version_class.new(latest_resolvable_version)
-          end
-
-          def updated_requirements
-            return requirements unless latest_resolvable_version
-
-            requirements.map do |req|
-              updated_req_string = update_requirement(
-                req[:requirement],
-                latest_resolvable_version
-              )
-
-              req.merge(requirement: updated_req_string)
-            end
-          end
-
-          private
-
-          attr_reader :requirements, :latest_resolvable_version
-
-          def update_requirement(old_req, new_version)
-            if requirement_class.new(old_req).satisfied_by?(new_version)
-              old_req
-            elsif (match = RANGE_REQUIREMENT_REGEX.match(old_req))
-              require_range(match[1], new_version)
-            elsif SINGLE_VERSION_REGEX.match?(old_req)
-              new_version.to_s
-            else
-              require_exactly(new_version)
-            end
-          end
-
-          def require_range(minimum, version)
-            major, _minor, _patch = version.to_s.split(".").map(&:to_i)
-            "#{minimum} <= v < #{major + 1}.0.0"
-          end
-
-          def require_exactly(version)
-            "#{version} <= v <= #{version}"
-          end
-
-          def version_class
-            Utils::Elm::Version
-          end
-
-          def requirement_class
-            Utils::Elm::Requirement
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dependabot/utils/elm/requirement.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "dependabot/utils/elm/version"
-
-module Dependabot
-  module Utils
-    module Elm
-      class Requirement < Gem::Requirement
-        # Override the version pattern to allow local versions
-        PATTERN_RAW =
-          "(#{Utils::Elm::Version::VERSION_PATTERN}) (<=?) v (<=?) " \
-          "(#{Utils::Elm::Version::VERSION_PATTERN})"
-        PATTERN = /\A#{PATTERN_RAW}\z/.freeze
-        EXACT_PATTERN = /\A#{Utils::Elm::Version::VERSION_PATTERN}\z/.freeze
-
-        # Returns an array of requirements. At least one requirement from the
-        # returned array must be satisfied for a version to be valid.
-        def self.requirements_array(requirement_string)
-          [new(requirement_string)]
-        end
-
-        # Override the parser to create Utils::Elm::Versions and return an
-        # array of parsed requirements
-        def self.parse(obj)
-          # If a version is given this is an equals requirement
-          if EXACT_PATTERN.match?(obj.to_s)
-            return [["=", Utils::Elm::Version.new(obj.to_s)]]
-          end
-
-          unless (matches = PATTERN.match(obj.to_s))
-            msg = "Illformed requirement #{obj.inspect}"
-            raise BadRequirementError, msg
-          end
-
-          # If the two versions specified are identical this is an equals
-          # requirement
-          if matches[1] == matches[4] && matches[3] == "<="
-            return [["=", Utils::Elm::Version.new(matches[4])]]
-          end
-
-          [
-            [matches[2].tr("<", ">"), Utils::Elm::Version.new(matches[1])],
-            [matches[3], Utils::Elm::Version.new(matches[4])]
-          ]
-        end
-
-        # Overwrite superclass method to use `flat_map`
-        def initialize(*requirements)
-          if requirements.any?(&:nil?)
-            raise BadRequirementError, "Nil requirement not supported in Elm"
-          end
-
-          requirements = requirements.flatten
-          requirements.compact!
-          requirements.uniq!
-
-          if requirements.empty?
-            @requirements = [DefaultRequirement]
-          else
-            @requirements = requirements.flat_map { |r| self.class.parse(r) }
-            sort_requirements!
-          end
-        end
-
-        # Overwrite superclass method to use `flat_map`
-        def concat(new)
-          new = new.flatten
-          new.compact!
-          new.uniq!
-          new = new.flat_map { |r| self.class.parse(r) }
-
-          @requirements.concat new
-          sort_requirements!
-        end
-
-        def sort_requirements!
-          @requirements.sort! do |l, r|
-            comp = l.last <=> r.last # first, sort by the requirement's version
-            next comp unless comp.zero?
-
-            l.first <=> r.first # then, sort by the operator (for stability)
-          end
-        end
-
-        def satisfied_by?(version)
-          version = Utils::Elm::Version.new(version.to_s)
-          super
-        end
-      end
-    end
-  end
-end

data/lib/dependabot/utils/elm/version.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-# Elm versions require major, minor and patch to be present
-# They don't allow any letters
-
-module Dependabot
-  module Utils
-    module Elm
-      class Version < Gem::Version
-        VERSION_PATTERN = "[0-9]+\.[0-9]+\.[0-9]+"
-        VERSION_PATTERN_REGEX = /\A#{VERSION_PATTERN}\Z/.freeze
-
-        def self.correct?(version)
-          version.to_s.match?(VERSION_PATTERN_REGEX)
-        end
-      end
-    end
-  end
-end