kettle-deps-floor 0.1.0

data/lib/kettle/deps/floor/cli.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "json"
+require "kettle/ndjson"
+require "open3"
+require "optparse"
+require "yaml"
+
+module Kettle
+  module Deps
+    module Floor
+      # Command-line entry point shared by the generic executable and project
+      # compatibility wrappers such as kettle-jem-deps-floor.
+      class CLI
+        DEFAULT_UPGRADE = "major"
+
+        def self.run(argv = ARGV, out: $stdout, err: $stderr, defaults: {})
+          options = parse_options(argv, defaults: defaults)
+          if options[:help]
+            out.puts(parser(defaults: defaults))
+            return 0
+          end
+          if options[:events] && options[:json]
+            raise OptionParser::InvalidOption, "--events cannot be combined with --json"
+          end
+          config = load_config(options.fetch(:config_path))
+          sources = options.fetch(:sources).empty? ? Array(config["sources"] || defaults[:sources] || ["*.gemspec"]) : options.fetch(:sources)
+          target_versions = config.fetch("target_versions", {}).merge(options.fetch(:target_versions))
+          holds = config.fetch("holds", {})
+          placeholder_pattern = options[:placeholder_pattern] || config["placeholder_pattern"] || defaults[:placeholder_pattern]
+          event_types = %w[run_start command_step summary]
+          events = Kettle::Ndjson.event_stream(out, types: event_types.join(","), event_types: event_types) if options[:events]
+          Kettle::Ndjson.emit_event(events, "run_start", command: "kettle-deps-floor", project_root: options.fetch(:project_root))
+          updater_options = {
+            project_root: options.fetch(:project_root),
+            sources: sources,
+            target_versions: target_versions,
+            upgrade: options.fetch(:upgrade),
+            gem_names: options.fetch(:gem_names),
+            holds: holds,
+            placeholder_pattern: placeholder_pattern
+          }
+          planned = Updater.new(**updater_options).run
+
+          if options[:write] && options[:commit] && planned.fetch(:updates).positive?
+            paths = planned.fetch(:planned_changes).map { |change| change.fetch(:relative_path) }.uniq
+            paths << "CHANGELOG.md" if options[:changelog]
+            dirty = dirty_paths(options.fetch(:project_root), paths)
+            raise "Refusing to commit because target files were already dirty: #{dirty.join(", ")}" unless dirty.empty?
+          end
+
+          result = if options[:write]
+            Updater.new(**updater_options, write: true).run
+          else
+            planned
+          end
+          emit_dependency_floor_events(events, result, write: options[:write])
+          changelog_result = write_changelog(options, config, result, defaults) if options[:write] && options[:changelog] && result.fetch(:updates).positive?
+          commit_result = commit_changes(options, result, changelog_result) if options[:write] && options[:commit] && result.fetch(:updates).positive?
+          print_result(options[:events] ? err : out, result, commit_result, changelog_result, json: options[:json])
+          return 1 if options[:check] && result.fetch(:updates).positive?
+
+          0
+        rescue OptionParser::ParseError, ArgumentError => error
+          err.puts(error.message)
+          err.puts(parser(defaults: defaults))
+          2
+        rescue => error
+          err.puts("#{error.class}: #{error.message}")
+          1
+        end
+
+        def self.parse_options(argv, defaults: {})
+          options = {
+            project_root: File.expand_path(defaults.fetch(:project_root, Dir.pwd)),
+            config_path: nil,
+            sources: [],
+            target_versions: {},
+            gem_names: [],
+            upgrade: DEFAULT_UPGRADE,
+            write: false,
+            check: false,
+            commit: true,
+            changelog: true,
+            json: false,
+            events: false,
+            placeholder_pattern: nil
+          }
+          parser(defaults: defaults, options: options).parse!(argv, into: options)
+          options[:project_root] = File.expand_path(argv.shift || options.fetch(:project_root))
+          raise OptionParser::InvalidArgument, "Expected at most one PROJECT_ROOT" unless argv.empty?
+
+          options[:config_path] ||= File.join(options.fetch(:project_root), defaults.fetch(:config_name, ".kettle-deps-floor.yml"))
+          options
+        end
+
+        def self.parser(defaults: {}, options: {})
+          OptionParser.new do |opts|
+            opts.banner = "Usage: #{defaults.fetch(:executable, "kettle-deps-floor")} [PROJECT_ROOT] [options]"
+            opts.on("--source GLOB", "Ruby source glob to scan; may be repeated.") { |value| options[:sources] << value }
+            opts.on("--target GEM=VERSION", "Set a family/release target version; may be repeated.") do |value|
+              name, version = value.split("=", 2)
+              raise OptionParser::InvalidArgument, "Expected GEM=VERSION, got #{value.inspect}" if name.to_s.empty? || version.to_s.empty?
+
+              options[:target_versions][name] = version
+            end
+            opts.on("--only GEMS", "Limit updates to comma-separated gem names.") { |value| options[:gem_names].concat(value.split(",").map(&:strip)) }
+            opts.on("--upgrade LEVEL", "Upgrade strategy: major, minor, patch (default: #{DEFAULT_UPGRADE}).") { |value| options[:upgrade] = value }
+            opts.on("-w", "--write", "Write dependency floor updates.") { options[:write] = true }
+            opts.on("--check", "Exit 1 when updates are available, without writing.") { options[:check] = true }
+            opts.on("--[no-]commit", "Commit the changed files when writing (default: true).") { |value| options[:commit] = value }
+            opts.on("--[no-]changelog", "Upsert an Unreleased changelog entry when writing (default: true).") { |value| options[:changelog] = value }
+            opts.on("--config PATH", "Read additional sources and holds from YAML.") { |value| options[:config_path] = File.expand_path(value) }
+            opts.on("--json", "Print a machine-readable JSON report.") { options[:json] = true }
+            opts.on("--events", "Emit compact NDJSON progress events to stdout; send the human report to stderr.") { options[:events] = true }
+            opts.on("--placeholder-pattern REGEXP", "Treat matches as opaque template tokens when parsing sources.") { |value| options[:placeholder_pattern] = value }
+            opts.on("-h", "--help", "Print this help.") { options[:help] = true }
+          end
+        end
+
+        def self.load_config(path)
+          return {} unless File.file?(path)
+
+          config = YAML.safe_load_file(path, permitted_classes: [], aliases: false) || {}
+          raise ArgumentError, "#{path} must contain a mapping" unless config.is_a?(Hash)
+
+          config
+        end
+
+        def self.write_changelog(options, config, result, defaults)
+          key = config.fetch("changelog_key", defaults.fetch(:changelog_key, "kettle-deps-floor"))
+          details = result.fetch(:planned_changes).group_by { |change| change.fetch(:name) }.map do |name, changes|
+            initial = changes.map { |change| Gem::Version.new(change.fetch(:current_floor)) }.min
+            latest = changes.map { |change| Gem::Version.new(change.fetch(:new_floor)) }.max
+            "  - #{name} (>= #{initial} -> >= #{latest})"
+          end
+          label = config.fetch("changelog_entry", defaults.fetch(:changelog_entry, "Update dependency floors:"))
+          entry = ([label] + details).join("\n")
+          command = ["kettle-changelog", "--upsert-unreleased-entry", "--section", "Changed", "--key", key, "--entry", entry]
+          stdout, stderr, status = Open3.capture3(*command, chdir: options.fetch(:project_root))
+          raise "kettle-changelog failed: #{stderr.empty? ? stdout : stderr}" unless status.success?
+
+          {status: "updated", output: stdout.strip}
+        end
+
+        def self.dirty_paths(root, paths)
+          return [] unless git(root, "rev-parse", "--show-toplevel", allow_failure: true)
+
+          git(root, "status", "--porcelain", "--", *paths).lines.map { |line| line[3..].to_s.strip }
+        end
+
+        def self.commit_changes(options, result, changelog_result)
+          root = options.fetch(:project_root)
+          relative_paths = result.fetch(:planned_changes).map { |change| change.fetch(:relative_path) }.uniq
+          relative_paths << "CHANGELOG.md" if changelog_result
+          relative_paths.uniq!
+          top = git(root, "rev-parse", "--show-toplevel", allow_failure: true)
+          return {status: "unavailable", reason: "not_git_repository"} unless top
+
+          changed = relative_paths.select { |path| File.file?(File.join(root, path)) }
+          return {status: "clean_noop"} if changed.empty?
+
+          git(root, "add", "--", *changed)
+          git(root, "commit", "-m", defaults_commit_message(result))
+          {status: "committed", files: changed}
+        end
+
+        def self.defaults_commit_message(result)
+          names = result.fetch(:updated_dependencies)
+          "⬆️ Raise dependency floors: #{names.join(", ")}"
+        end
+
+        def self.git(root, *args, allow_failure: false)
+          stdout, stderr, status = Open3.capture3("git", *args, chdir: root)
+          return stdout if status.success?
+          return nil if allow_failure
+
+          raise "git #{args.join(" ")} failed: #{stderr.empty? ? stdout : stderr}"
+        end
+
+        def self.emit_dependency_floor_events(events, result, write:)
+          return unless events
+
+          result.fetch(:planned_changes).each_with_index do |change, index|
+            Kettle::Ndjson.emit_event(
+              events,
+              "command_step",
+              phase: "dependency_floor",
+              name: "raise_floor",
+              status: write ? "updated" : "planned",
+              index: index + 1,
+              total: result.fetch(:planned_changes).length,
+              gem_name: change.fetch(:name),
+              path: change.fetch(:relative_path),
+              current_floor: change.fetch(:current_floor),
+              new_floor: change.fetch(:new_floor)
+            )
+          end
+          status = if write
+            "updated"
+          else
+            "planned"
+          end
+          status = "ok" unless result.fetch(:updates).positive?
+          Kettle::Ndjson.emit_summary_event(
+            events,
+            command: "kettle-deps-floor",
+            status: status,
+            updates: result.fetch(:updates),
+            updated_dependencies: result.fetch(:updated_dependencies)
+          )
+        end
+
+        def self.print_result(out, result, commit_result, changelog_result, json:)
+          if json
+            out.puts(JSON.pretty_generate(result.merge(commit: commit_result, changelog: changelog_result)))
+            return
+          end
+
+          out.puts("deps-floor: mode=#{result.fetch(:mode)} upgrade=#{result.fetch(:upgrade)}")
+          out.puts("deps-floor: #{result.fetch(:updates)} update#{"s" unless result.fetch(:updates) == 1}")
+          result.fetch(:planned_changes).each do |change|
+            out.puts("  #{change.fetch(:name)} #{change.fetch(:relative_path)} >= #{change.fetch(:current_floor)} -> >= #{change.fetch(:new_floor)}")
+          end
+          out.puts("changelog: #{changelog_result.fetch(:status)}") if changelog_result
+          out.puts("commit: #{commit_result.fetch(:status)}") if commit_result
+          if result.fetch(:mode) == "dry-run" && result.fetch(:updates).positive?
+            out.puts("hint: rerun with --write --upgrade #{result.fetch(:upgrade)} to apply updates")
+          end
+        end
+
+        private_class_method :parser
+      end
+    end
+  end
+end

data/lib/kettle/deps/floor/registry_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "kettle/dev"
+
+module Kettle
+  module Deps
+    module Floor
+      # Registry adapter backed by kettle-dev's shared persistent RubyGems cache.
+      class RegistryResolver
+        def versions(gem_name, requirements: nil)
+          Kettle::Dev::RubyGemsVersions.fetch(gem_name).filter_map do |entry|
+            number = entry["number"] || entry[:number]
+            next if number.to_s.empty?
+            next if prerelease_entry?(entry, number)
+            next if requirements && !Gem::Requirement.new(*requirements).satisfied_by?(Gem::Version.new(number.to_s))
+
+            {number: number.to_s}
+          end
+        end
+
+        private
+
+        def prerelease_entry?(entry, number)
+          prerelease = entry["prerelease"] || entry[:prerelease]
+          explicitly_prerelease = prerelease == true || prerelease.to_s.match?(/\A(?:1|true|yes|on)\z/i)
+          explicitly_prerelease || Gem::Version.new(number.to_s).prerelease?
+        end
+      end
+    end
+  end
+end

data/lib/kettle/deps/floor/updater.rb

@@ -0,0 +1,398 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require "rubygems"
+require "kettle/dev"
+
+module Kettle
+  module Deps
+    module Floor
+      # Finds explicit lower-bound dependency requirements in configured Ruby
+      # sources and raises them either to a supplied family version or to a
+      # registry version bounded by the selected upgrade level.
+      class Updater
+        DEPENDENCY_METHODS = %i[add_dependency add_runtime_dependency add_development_dependency].freeze
+        GEMFILE_METHODS = %i[gem].freeze
+        ASSIGNMENT_NAMES = %i[nomono_requirements nomono_activation_requirements].freeze
+        VALID_UPGRADES = %w[major minor patch].freeze
+
+        def initialize(project_root:, sources: ["*.gemspec"], resolver: RegistryResolver.new, target_versions: {},
+          upgrade: "major", write: false, check: false, gem_names: nil, holds: {}, registry_updates: true,
+          placeholder_pattern: nil)
+          @project_root = File.expand_path(project_root)
+          @sources = Array(sources).map(&:to_s)
+          @resolver = resolver
+          @target_versions = target_versions.transform_keys(&:to_s).transform_values { |value| Gem::Version.new(value.to_s) }
+          @upgrade = upgrade.to_s
+          @write = write
+          @check = check
+          @gem_names = Array(gem_names).map(&:to_s)
+          @holds = holds.transform_keys(&:to_s)
+          @registry_updates = registry_updates
+          @placeholder_pattern = placeholder_pattern && Regexp.new(placeholder_pattern.to_s)
+        end
+
+        attr_reader :project_root, :sources, :resolver, :target_versions, :upgrade, :gem_names, :holds, :registry_updates, :placeholder_pattern
+
+        def self.dependency_names(project_root:, sources:)
+          new(project_root: project_root, sources: sources).dependencies
+        end
+
+        def dependencies
+          dependency_records.map { |record| record.fetch(:name) }.uniq
+        end
+
+        def run
+          validate_options!
+          records = dependency_records
+          planned_changes = records.filter_map { |record| plan_record(record) }
+          apply_changes(planned_changes) if @write
+          {
+            mode: @write ? "write" : "dry-run",
+            check: !!@check,
+            upgrade: upgrade,
+            discovered_dependencies: records.map { |record| record.fetch(:name) }.uniq.sort,
+            updates: planned_changes.length,
+            updated_dependencies: planned_changes.map { |change| change.fetch(:name) }.uniq.sort,
+            planned_changes: planned_changes.map { |change| serializable_change(change) }
+          }
+        end
+
+        private
+
+        def validate_options!
+          return if VALID_UPGRADES.include?(upgrade)
+
+          raise ArgumentError, "Invalid upgrade level #{upgrade.inspect}; use one of: #{VALID_UPGRADES.join(", ")}"
+        end
+
+        def dependency_records
+          source_paths.flat_map { |relative_path| records_for_path(relative_path) }.uniq do |record|
+            [record.fetch(:relative_path), record.fetch(:name), record.fetch(:floor_range).fetch(:start_offset)]
+          end
+        end
+
+        def source_paths
+          sources.flat_map do |pattern|
+            Dir.glob(File.join(project_root, pattern), File::FNM_DOTMATCH).select { |path| File.file?(path) }
+          end.uniq.sort.map { |path| relative_path(path) }
+        end
+
+        def relative_path(path)
+          Pathname(path).relative_path_from(Pathname(project_root)).to_s
+        end
+
+        def records_for_path(relative_path)
+          path = File.join(project_root, relative_path)
+          source = File.read(path)
+          spans = placeholder_spans(source)
+          parse_result = Kettle::Dev::VersionBump.parse_source(spans.empty? ? source : sanitize_placeholders(source, spans), path)
+          nodes = Kettle::Dev::VersionBump.each_node(parse_result.value)
+          records = nodes.flat_map do |node|
+            [
+              call_record(node, source, relative_path),
+              assignment_record(node, source, relative_path),
+              *Array(registry_records(node, source, relative_path))
+            ].compact
+          end + embedded_text_records(source, relative_path)
+          return records if spans.empty?
+
+          # Records whose floor or pessimistic requirement sits inside a
+          # substituted placeholder span are not editable (the placeholder owns
+          # those bytes), and names manufactured by the substitution sentinel
+          # are not real gems.
+          records.reject do |record|
+            sentinel_name?(record.fetch(:name)) ||
+              span_touched?(spans, record.fetch(:floor_range)) ||
+              (record[:pessimistic_range] && span_touched?(spans, record.fetch(:pessimistic_range)))
+          end
+        rescue Kettle::Dev::Error => error
+          raise Error, error.message
+        end
+
+        # Template placeholders such as kettle-jem's {KJ|TOKEN} are not valid
+        # Ruby in code positions, which makes the whole source unparseable.
+        # Each placeholder span is replaced with an equal-length constant token
+        # so Prism offsets still map 1:1 onto the original bytes; a constant
+        # parses in every position a placeholder occupies (statement, value,
+        # argument, `::` namespace segment), and it never becomes a StringNode,
+        # so substituted regions can never yield editable floor records.
+        # A placeholder glued to a preceding closing token (`)`, `"`, `}`)
+        # gets a `::`-prefixed constant instead, so e.g. `call("exe"){KJ|X}`
+        # parses as a constant path; inside string literals either shape is
+        # inert text.
+        def placeholder_spans(source)
+          return [] unless placeholder_pattern
+
+          spans = []
+          position = 0
+          while (match = placeholder_pattern.match(source, position))
+            spans << [match.begin(0), match.end(0)]
+            position = match.end(0)
+          end
+          spans
+        end
+
+        def sanitize_placeholders(source, spans)
+          sanitized = source.dup
+          spans.each do |start_offset, end_offset|
+            length = end_offset - start_offset
+            previous = start_offset.zero? ? nil : sanitized[start_offset - 1]
+            token = if previous && %[) " }].include?(previous) && length >= 3
+              "::C" + ("x" * (length - 3))
+            else
+              "C" + ("x" * (length - 1))
+            end
+            sanitized[start_offset...end_offset] = token
+          end
+          sanitized
+        end
+
+        def sentinel_name?(name)
+          name.match?(/\ACx{4,}\z/)
+        end
+
+        def span_touched?(spans, range)
+          spans.any? { |start_offset, end_offset| range.fetch(:start_offset) < end_offset && start_offset < range.fetch(:end_offset) }
+        end
+
+        def call_record(node, source, relative_path)
+          return unless node.is_a?(Prism::CallNode)
+          dependency_call = DEPENDENCY_METHODS.include?(node.name)
+          gemfile_call = node.receiver.nil? && GEMFILE_METHODS.include?(node.name)
+          return if !dependency_call && !gemfile_call
+
+          arguments = node.arguments&.arguments || []
+          name_node = arguments.first
+          return unless name_node.is_a?(Prism::StringNode)
+
+          record_from_nodes(name_node.unescaped, arguments.drop(1), source, relative_path, "gemspec_or_gemfile")
+        end
+
+        def assignment_record(node, source, relative_path)
+          return unless node.is_a?(Prism::LocalVariableWriteNode) && ASSIGNMENT_NAMES.include?(node.name)
+          return unless node.value.is_a?(Prism::ArrayNode)
+
+          record_from_nodes("nomono", node.value.elements, source, relative_path, "requirement_assignment")
+        end
+
+        # Registry entries are ordinary Ruby AST; only embedded examples need
+        # text scanning because their %(...) delimiters are not valid Ruby.
+        def registry_records(node, source, relative_path)
+          return unless node.is_a?(Prism::ConstantWriteNode)
+          registry = node.name
+          value = node.value
+          value = value.receiver if value.is_a?(Prism::CallNode) && value.name == :freeze
+          case registry
+          when :TEMPLATE_MANAGED_DEPENDENCIES
+            return unless value.is_a?(Prism::ArrayNode)
+            value.elements.filter_map do |entry|
+              next unless entry.is_a?(Prism::HashNode)
+              fields = entry.elements.to_h do |assoc|
+                [assoc.key.unescaped.to_s, assoc.value] if assoc.is_a?(Prism::AssocNode) && assoc.key.is_a?(Prism::SymbolNode)
+              end.compact
+              name_node = fields["name"]
+              name = name_node.unescaped if name_node.is_a?(Prism::StringNode)
+              reqs = fields["requirements"]
+              record_from_nodes(name, reqs.elements, source, relative_path, "template_registry") if reqs.is_a?(Prism::ArrayNode)
+            end
+          when :GEMSPEC_DEPENDENCY_MINIMUM_REQUIREMENTS
+            return unless value.is_a?(Prism::HashNode)
+            value.elements.filter_map do |assoc|
+              next unless assoc.is_a?(Prism::AssocNode) && assoc.key.is_a?(Prism::StringNode) && assoc.value.is_a?(Prism::StringNode)
+              record_from_nodes(assoc.key.unescaped, [assoc.value], source, relative_path, "gemspec_floor")
+            end
+          end
+        end
+
+        def embedded_text_records(source, relative_path)
+          # Regex is intentionally limited to invalid-Ruby embedded template text;
+          # Prism cannot expose dependency calls inside %(...) string contents.
+          return [] unless source.include?("%(")
+
+          pattern = /%\(gem\s+"([A-Za-z0-9_.-]+)"\s*,\s*"(~> [^"]+)"\s*,\s*"(>= [^"]+)"/
+          # A position-loop with explicit MatchData: Regexp.last_match inside a
+          # to_enum(:scan) block is unreliable on TruffleRuby.
+          records = []
+          position = 0
+          while (match = pattern.match(source, position))
+            position = match.end(0)
+            pessimistic_offset = source[0...match.begin(2)].bytesize - 1
+            floor_offset = source[0...match.begin(3)].bytesize - 1
+            record = record_from_ranges(
+              match[1],
+              "embedded_template_text",
+              source,
+              relative_path,
+              match[2],
+              {start_offset: pessimistic_offset, end_offset: pessimistic_offset + match[2].bytesize + 2},
+              match[3],
+              {start_offset: floor_offset, end_offset: floor_offset + match[3].bytesize + 2},
+              [match[2], match[3]]
+            )
+            records << record if record
+          end
+          records
+        end
+
+        def record_from_nodes(name, nodes, source, relative_path, source_kind)
+          return unless name.is_a?(String) && name.match?(/\A[a-zA-Z0-9_.-]+\z/)
+          return if !gem_names.empty? && !gem_names.include?(name)
+
+          requirements = string_nodes(nodes)
+          floor = requirements.find { |entry| entry.unescaped.start_with?(">=") }
+          return unless floor
+
+          pessimistic = requirements.find { |entry| entry.unescaped.start_with?("~>") }
+          record_from_ranges(
+            name,
+            source_kind,
+            source,
+            relative_path,
+            pessimistic&.unescaped,
+            pessimistic && node_range(pessimistic),
+            floor.unescaped,
+            node_range(floor),
+            requirements.map(&:unescaped)
+          )
+        end
+
+        def record_from_ranges(name, source_kind, source, relative_path, pessimistic, pessimistic_range, floor, floor_range, requirements)
+          return unless name.is_a?(String) && name.match?(/\A[a-zA-Z0-9_.-]+\z/)
+          return if !gem_names.empty? && !gem_names.include?(name)
+
+          {
+            name: name,
+            relative_path: relative_path,
+            source_kind: source_kind,
+            source: source,
+            current_pessimistic: pessimistic,
+            current_floor: floor_version(floor),
+            pessimistic_range: pessimistic_range,
+            floor_range: floor_range,
+            requirements: requirements
+          }
+        rescue ArgumentError
+          nil
+        end
+
+        def string_nodes(nodes)
+          Array(nodes).flat_map do |node|
+            case node
+            when Prism::StringNode
+              [node]
+            when Prism::ArrayNode
+              string_nodes(node.elements)
+            else
+              []
+            end
+          end
+        end
+
+        def floor_version(requirement)
+          entry = Gem::Requirement.new(requirement).requirements.find { |operator, _version| operator == ">=" }
+          raise ArgumentError, "Expected >= requirement, got #{requirement.inspect}" unless entry
+
+          entry.last
+        end
+
+        def node_range(node)
+          {start_offset: node.location.start_offset, end_offset: node.location.end_offset}
+        end
+
+        def plan_record(record)
+          name = record.fetch(:name)
+          return if holds.key?(name)
+
+          current = record.fetch(:current_floor)
+          target = target_versions[name]
+          target ||= registry_target(record, current) if registry_updates
+          return unless target && target > current
+          return unless target_compatible?(record, target)
+
+          new_pessimistic = if target_versions.key?(name) || !record[:pessimistic_range]
+            nil
+          else
+            pessimistic_requirement_for(target)
+          end
+          record.merge(
+            current_floor_version: current,
+            new_floor_version: target,
+            new_pessimistic: new_pessimistic
+          )
+        end
+
+        def registry_target(record, current)
+          requirements = requirements_for_upgrade(current)
+          versions = resolver.versions(record.fetch(:name), requirements: requirements)
+          Array(versions).filter_map do |entry|
+            version = entry[:number] || entry["number"]
+            Gem::Version.new(version.to_s) unless version.to_s.empty?
+          end.max
+        end
+
+        def requirements_for_upgrade(current)
+          major = current.segments.fetch(0)
+          minor = current.segments.fetch(1, 0)
+          case upgrade
+          when "patch"
+            [">= #{current}", "~> #{major}.#{minor}.0"]
+          when "minor"
+            [">= #{current}", "~> #{major}.0"]
+          else
+            [">= #{current}"]
+          end
+        end
+
+        def target_compatible?(record, target)
+          fixed_constraints = record.fetch(:requirements).reject { |requirement| requirement.start_with?(">=") }
+          Gem::Requirement.new(*fixed_constraints).satisfied_by?(target)
+        rescue ArgumentError
+          false
+        end
+
+        def pessimistic_requirement_for(version)
+          segments = version.segments
+          "~> #{segments.fetch(0)}.#{segments.fetch(1, 0)}"
+        end
+
+        def apply_changes(changes)
+          edits = changes.flat_map do |change|
+            replacements = []
+            if change[:new_pessimistic]
+              replacements << edit(change, change.fetch(:pessimistic_range), change.fetch(:new_pessimistic))
+            end
+            replacements << edit(change, change.fetch(:floor_range), ">= #{change.fetch(:new_floor_version)}")
+            replacements
+          end
+          Kettle::Dev::VersionBump.write_edits(edits)
+        end
+
+        def edit(change, range, value)
+          source = change.fetch(:source)
+          original = source.byteslice(range.fetch(:start_offset), range.fetch(:end_offset) - range.fetch(:start_offset))
+          Kettle::Dev::VersionBump.file_edit(
+            File.join(project_root, change.fetch(:relative_path)),
+            source,
+            range.fetch(:start_offset),
+            range.fetch(:end_offset),
+            Kettle::Dev::VersionBump.quote_like(original, value)
+          )
+        end
+
+        def serializable_change(change)
+          {
+            name: change.fetch(:name),
+            relative_path: change.fetch(:relative_path),
+            source_kind: change.fetch(:source_kind),
+            current_floor: change.fetch(:current_floor_version).to_s,
+            new_floor: change.fetch(:new_floor_version).to_s,
+            current_pessimistic: change[:current_pessimistic],
+            new_pessimistic: change[:new_pessimistic]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kettle/deps/floor/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kettle
+  module Deps
+    module Floor
+      # Version namespace for this gem.
+      module Version
+        # Current gem version.
+        VERSION = "0.1.0"
+      end
+      # Current gem version exposed at the traditional constant location.
+      VERSION = Version::VERSION # Traditional Constant Location
+    end
+  end
+end