graphql-modernize 0.1.0

data/lib/graphql/modernize/application.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require "etc"
+require "open3"
+
+module GraphQL
+  module Modernize
+    class Application
+      FileResult = Data.define(:source_file, :rewritten, :offenses)
+      Result = Data.define(:files, :parse_errors, :iterations)
+
+      def initialize(config:, rules: RuleRegistry.all, jobs: Etc.nprocessors, explicit_rule_ids: [])
+        @config = config
+        @rules = rules
+        @explicit_rule_ids = explicit_rule_ids.map { |id| id.to_s.upcase }.freeze
+        @jobs = Integer(jobs)
+        raise Error, "jobs must be an integer greater than or equal to 1" unless @jobs.positive?
+      end
+
+      def run(paths = [])
+        files = FileFinder.new(@config).find(paths)
+        originals = files.to_h do |path|
+          source_file = Astel::SourceFile.parse(path: path, version: @config.ruby_version)
+          [path, source_file.source]
+        end
+        current = originals.dup
+        corrected_offenses = Hash.new { |hash, path| hash[path] = [] }
+        current_offenses = Hash.new { |hash, path| hash[path] = [] }
+        parse_errors = []
+        iterations = 0
+
+        (@config.iterations + 2).times do |iteration|
+          iterations = iteration + 1
+          source_files = parse_sources(current, parse_errors)
+          hierarchy = ClassHierarchy.new(base_classes: @config.base_classes).build(source_files)
+          iteration_results = process_files(source_files.map(&:path), current, hierarchy)
+          changed = false
+
+          iteration_results.each do |path, rewritten, found|
+            current_offenses[path] = found
+            corrected_offenses[path].concat(found.select(&:corrected?))
+            changed ||= current[path] != rewritten
+            current[path] = rewritten
+          end
+          break unless changed
+
+          next unless iterations > @config.iterations + 1
+
+          rule_ids = iteration_results.flat_map do |_path, _rewritten, found|
+            found.filter_map do |offense|
+              offense.rule_id if offense.corrected? || offense.conflicting_rule_id
+            end
+          end.uniq.sort
+          detail = rule_ids.empty? ? "" : " (related rules: #{rule_ids.join(', ')})"
+          raise Error, "rewrites did not converge after #{@config.iterations} retry iterations#{detail}"
+        end
+
+        results = originals.map do |path, source|
+          source_file = Astel::SourceFile.from_string(source, path: path, version: @config.ruby_version)
+          unresolved = current_offenses[path].reject(&:corrected?)
+          FileResult.new(source_file: source_file, rewritten: current[path],
+                         offenses: corrected_offenses[path] + unresolved)
+        end
+        Result.new(files: results, parse_errors: parse_errors.uniq, iterations: iterations)
+      end
+
+      def ensure_write_safe!(paths: [], force: false)
+        return if force
+
+        output, _error, status = Open3.capture3("git", "-C", @config.root, "rev-parse", "--is-inside-work-tree")
+        unless status.success? && output.strip == "true"
+          raise Error, "--write must run inside a Git working tree (use --force to override)"
+        end
+
+        output, error, status = Open3.capture3("git", "-C", @config.root, "status", "--porcelain")
+        raise Error, "Unable to inspect the Git working tree: #{error.strip}" unless status.success?
+
+        raise Error, "The working tree is not clean (use --force to override)" unless output.empty?
+
+        output, error, status = Open3.capture3("git", "-C", @config.root, "rev-parse", "--show-toplevel")
+        raise Error, "Unable to determine the Git working tree root: #{error.strip}" unless status.success?
+
+        root = File.realpath(output.strip)
+        prefix = "#{root}#{File::SEPARATOR}"
+        files = FileFinder.new(@config).find(paths)
+        unsafe = files.find do |path|
+          !File.realpath(path).start_with?(prefix) || File.lstat(path).symlink?
+        end
+        raise Error, "A --write target is outside the Git working tree or is a symbolic link: #{unsafe}" if unsafe
+
+        output, error, status = Open3.capture3("git", "-C", root, "ls-files", "-z")
+        raise Error, "Unable to inspect Git-tracked files: #{error.strip}" unless status.success?
+
+        tracked = output.split("\0").to_h { |path| [File.join(root, path), true] }
+        untracked = files.find { |path| !tracked[File.realpath(path)] }
+        raise Error, "A --write target is not tracked by Git: #{untracked}" if untracked
+      end
+
+      def write(result)
+        result.files.each do |file|
+          next if file.source_file.source == file.rewritten
+
+          File.binwrite(file.source_file.path, file.rewritten)
+        end
+      end
+
+      private
+
+      def parse_sources(contents, parse_errors)
+        contents.filter_map do |path, source|
+          parsed = Astel::SourceFile.from_string(source, path: path, version: @config.ruby_version)
+          if parsed.valid?
+            parsed
+          else
+            parse_errors << [path, parsed.errors.map(&:message)]
+            nil
+          end
+        end
+      end
+
+      def process_files(paths, contents, hierarchy)
+        sequential = @jobs == 1 || !Process.respond_to?(:fork)
+        return paths.map { |path| process_file(path, contents.fetch(path), hierarchy) } if sequential
+
+        paths.each_slice(@jobs).flat_map do |batch|
+          workers = batch.map do |path|
+            reader, writer = IO.pipe
+            pid = Process.fork do
+              reader.close
+              Marshal.dump([true, process_file(path, contents.fetch(path), hierarchy)], writer)
+            rescue StandardError => e
+              Marshal.dump([false, [e.class.name, e.message]], writer)
+            ensure
+              writer.close
+              exit! 0
+            end
+            writer.close
+            [pid, reader]
+          end
+          workers.map do |pid, reader|
+            success, payload = Marshal.load(reader) # rubocop:disable Security/MarshalLoad -- trusted forked worker only
+            Process.wait(pid)
+            raise Error, "worker failed: #{payload.join(': ')}" unless success
+
+            payload
+          ensure
+            reader.close
+          end
+        end
+      end
+
+      def process_file(path, source, hierarchy)
+        source_file = Astel::SourceFile.from_string(source, path: path, version: @config.ruby_version)
+        found, rewriter = Runner.new(hierarchy: hierarchy, config: @config,
+                                     explicit_rule_ids: @explicit_rule_ids).run(source_file, @rules)
+        [path, rewriter.rewrite(validate: :parse), found]
+      rescue Astel::Rewriter::ValidationError => e
+        rules = found ? found.select(&:corrected?).map(&:rule_id).uniq.sort : []
+        edits = if rewriter
+                  rewriter.edits.map do |edit|
+                    "#{edit.start_offset}...#{edit.end_offset}=#{edit.replacement.inspect}"
+                  end
+                else
+                  []
+                end
+        raise Error, "Rewritten source failed syntax validation: #{path}; rules=#{rules.join(',')}; " \
+                     "edits=[#{edits.join(', ')}]; errors=#{e.parse_errors.map(&:message).join(', ')}; " \
+                     "Please report an issue with reproduction details."
+      end
+    end
+  end
+end

data/lib/graphql/modernize/class_hierarchy.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    ClassDeclaration = Data.define(:path, :start_offset, :end_offset, :name, :superclass, :module_node)
+    VisibleDefinition = Data.define(:class_name, :path, :line)
+    SchemaCall = Data.define(:name, :first_argument, :path, :start_offset, :direct)
+    HierarchyNodes = Data.define(:declarations, :calls, :method_nodes, :singleton_classes, :scopes)
+
+    module HierarchyScanner
+      module_function
+
+      def call(ast)
+        declarations = []
+        calls = []
+        methods = []
+        singleton_classes = []
+        scopes = []
+        dispatcher = Astel::Dispatcher.new
+        dispatcher.on(:class_node) { |node| declarations << [node, false] }
+        dispatcher.on(:module_node) { |node| declarations << [node, true] }
+        dispatcher.on(:call_node) { |node| calls << node if node.receiver.nil? }
+        dispatcher.on(:def_node) do |node|
+          methods << node
+          scopes << node
+        end
+        dispatcher.on(:alias_method_node) { |node| methods << node }
+        dispatcher.on(:block_node) { |node| scopes << node }
+        dispatcher.on(:lambda_node) { |node| scopes << node }
+        dispatcher.on(:singleton_class_node) do |node|
+          singleton_classes << node if node.expression.is_a?(Prism::SelfNode)
+        end
+        dispatcher.run(ast)
+        HierarchyNodes.new(declarations: declarations, calls: calls, method_nodes: methods,
+                           singleton_classes: singleton_classes, scopes: scopes)
+      end
+    end
+
+    module MethodDeclarations
+      module_function
+
+      def body_statements(nodes)
+        {}.compare_by_identity.tap do |result|
+          add = lambda do |statements|
+            statements&.body&.each do |statement|
+              result[statement] = true
+              plain_begin = statement.is_a?(Prism::BeginNode) && !statement.rescue_clause &&
+                            !statement.else_clause && !statement.ensure_clause
+              add.call(statement.statements) if plain_begin
+            end
+          end
+          nodes.each { |node| add.call(node.body) }
+        end
+      end
+
+      def select(methods, calls, body_statements)
+        wrapped = calls.select do |call|
+          body_statements.key?(call) && %i[private protected public].include?(call.name)
+        end.flat_map { |call| call.arguments&.arguments.to_a }.grep(Prism::DefNode)
+        methods.select { |method| body_statements.key?(method) || wrapped.include?(method) }
+      end
+
+      def calls(calls, body_statements)
+        direct = calls.select { |call| body_statements.key?(call) }
+        wrapped = direct.select { |call| %i[private protected public].include?(call.name) }
+                        .flat_map { |call| call.arguments&.arguments.to_a }.grep(Prism::CallNode)
+        direct.concat(wrapped).to_h { |call| [call, true] }.compare_by_identity
+      end
+
+      def names(call)
+        names = call.arguments&.arguments.to_a.filter_map do |argument|
+          argument.unescaped.to_sym if argument.is_a?(Prism::SymbolNode) || argument.is_a?(Prism::StringNode)
+        end
+        return names if %i[attr attr_reader attr_accessor].include?(call.name)
+        return names.first(1) if %i[alias_method define_method define_singleton_method].include?(call.name)
+
+        []
+      end
+
+      def class_method?(call, singleton_classes)
+        call.name == :define_singleton_method || singleton_classes.any? do |scope|
+          call.location.start_offset > scope.location.start_offset &&
+            call.location.end_offset < scope.location.end_offset
+        end
+      end
+    end
+
+    class ClassHierarchy
+      DIRECT_KINDS = {
+        "GraphQL::Schema::Object" => :object,
+        "GraphQL::Schema::InputObject" => :input_object,
+        "GraphQL::Schema::Enum" => :enum,
+        "GraphQL::Schema::Union" => :union,
+        "GraphQL::Schema::Resolver" => :resolver,
+        "GraphQL::Schema::Mutation" => :mutation,
+        "GraphQL::Schema::RelayClassicMutation" => :mutation,
+        "GraphQL::Schema::Subscription" => :subscription,
+        "GraphQL::Schema" => :schema
+      }.freeze
+      SUFFIX_KINDS = {
+        "BaseObject" => :object,
+        "BaseInputObject" => :input_object,
+        "BaseEnum" => :enum,
+        "BaseUnion" => :union,
+        "BaseResolver" => :resolver,
+        "BaseMutation" => :mutation
+      }.freeze
+
+      attr_reader :declarations
+
+      def initialize(base_classes: {})
+        @configured_kinds = base_classes.each_with_object({}) do |(kind, names), result|
+          Array(names).each { |name| result[normalize(name)] = kind.to_sym }
+        end
+        @declarations = {}
+        @declared_names = {}
+        @superclasses = {}
+        @interface_names = {}
+        @visible_definitions = []
+        @calls = Hash.new { |hash, name| hash[name] = [] }
+        @methods = Hash.new { |hash, name| hash[name] = {} }
+        @class_methods = Hash.new { |hash, name| hash[name] = {} }
+      end
+
+      def build(source_files) = tap { source_files.each { |source_file| index(source_file) } }
+
+      def resolve_kind(class_name)
+        name = normalize(class_name)
+        seen = {}
+        until name.empty? || seen[name]
+          seen[name] = true
+          kind = direct_kind(name)
+          return kind if kind
+
+          name = resolve_superclass(name)
+        end
+        nil
+      end
+
+      def calls_for(class_name) = ancestors(class_name).flat_map { |name| @calls[name] }
+
+      def method_defined?(class_name, method_name) = defined_in?(@methods, class_name, method_name)
+
+      def class_method_defined?(class_name, method_name) = defined_in?(@class_methods, class_name, method_name)
+
+      def visible_definitions = @visible_definitions.select { |definition| visible_definition?(definition) }
+
+      def visibility_plugin?(class_name)
+        calls_for(class_name).any? do |call|
+          call.direct && call.name == :use &&
+            %w[GraphQL::Schema::Visibility GraphQL::Schema::Warden].include?(call.first_argument)
+        end
+      end
+
+      def visibility_plugin_ambiguous?(class_name)
+        !visibility_plugin?(class_name) && calls_for(class_name).any? do |call|
+          call.name == :use && %w[GraphQL::Schema::Visibility GraphQL::Schema::Warden].include?(call.first_argument)
+        end
+      end
+
+      def visibility_plugin_target?(class_name)
+        return false if visibility_plugin?(class_name)
+
+        ancestors(class_name).drop(1).none? do |name|
+          @declared_names[name] && resolve_kind(name) == :schema && !visibility_plugin?(name)
+        end
+      end
+
+      def visibility_plugin_misplaced?(class_name, path, start_offset)
+        @calls[normalize(class_name)].any? do |call|
+          call.direct && call.path == path && call.start_offset > start_offset &&
+            %i[query mutation subscription].include?(call.name)
+        end
+      end
+
+      private
+
+      def visible_definition?(item) = resolve_kind(item.class_name) && !DIRECT_KINDS.key?(item.class_name)
+
+      def defined_in?(table, class_name, name) = ancestors(class_name).any? { |ancestor| table[ancestor][name.to_sym] }
+
+      def index(source_file)
+        scan = HierarchyScanner.call(source_file.ast)
+        nodes = scan.declarations
+        calls = scan.calls
+        methods = scan.method_nodes
+        singleton_classes = scan.singleton_classes
+        includes = calls.select do |node|
+          node.name == :include &&
+            node.arguments&.arguments&.any? { |arg| constant_name(arg) == "GraphQL::Schema::Interface" }
+        end
+
+        body_statements = MethodDeclarations.body_statements(nodes.map(&:first) + singleton_classes)
+        includes.select! { |call| body_statements.key?(call) }
+        calls.reject! { |call| scan.scopes.any? { |scope| nested_in?(scope, call) } }
+        methods = MethodDeclarations.select(methods, calls, body_statements)
+        method_calls = MethodDeclarations.calls(calls, body_statements)
+
+        name_cache = {}.compare_by_identity
+        resolve_name = lambda do |node|
+          name_cache[node] ||= begin
+            raw_name = constant_name(node.constant_path)
+            parent = nodes.filter_map do |candidate, _candidate_module|
+              next if candidate.equal?(node)
+              next unless candidate.location.start_offset < node.location.start_offset &&
+                          candidate.location.end_offset >= node.location.end_offset
+
+              candidate
+            end.min_by { |candidate| candidate.location.end_offset - candidate.location.start_offset }
+            qualify(raw_name, parent && resolve_name.call(parent))
+          end
+        end
+
+        entries = nodes.sort_by { |node, _module_node| node.location.start_offset }.map do |node, module_node|
+          superclass = node.respond_to?(:superclass) ? constant_name(node.superclass) : nil
+          ClassDeclaration.new(path: source_file.path, start_offset: node.location.start_offset,
+                               end_offset: node.location.end_offset, name: resolve_name.call(node),
+                               superclass: superclass, module_node: module_node)
+        end
+        offset_map = entries.to_h { |entry| [entry.start_offset, entry] }
+        @declarations[source_file.path] = offset_map
+        index_metadata(source_file, entries, includes, calls, methods, singleton_classes, body_statements, method_calls)
+      end
+
+      def index_metadata(source_file, entries, includes, calls, methods, singleton_classes, body_statements,
+                         method_calls)
+        entries.each do |entry|
+          @declared_names[entry.name] = true
+          @superclasses[entry.name] = entry.superclass if entry.superclass
+        end
+        includes.each do |call|
+          owner = owner_for(entries, call)
+          @interface_names[owner.name] = true if owner&.module_node
+        end
+        calls.each do |call|
+          owner = owner_for(entries, call)
+          next unless owner
+
+          @calls[owner.name] << SchemaCall.new(name: call.name, first_argument: first_argument(call),
+                                               path: source_file.path, start_offset: call.location.start_offset,
+                                               direct: body_statements.key?(call))
+          names = MethodDeclarations.names(call)
+          if method_calls.key?(call) && !names.empty?
+            table = MethodDeclarations.class_method?(call, singleton_classes) ? @class_methods : @methods
+            names.each { |name| table[owner.name][name] = true }
+          end
+        end
+        methods.each do |node|
+          owner = owner_for(entries, node)
+          next unless owner
+
+          inside_singleton = singleton_classes.any? { |scope| nested_in?(scope, node) }
+          if node.is_a?(Prism::AliasMethodNode)
+            (inside_singleton ? @class_methods : @methods)[owner.name][node.new_name.unescaped.to_sym] = true
+            next
+          end
+
+          next if node.receiver && !node.receiver.is_a?(Prism::SelfNode)
+
+          class_method = node.receiver.is_a?(Prism::SelfNode) || inside_singleton
+          (class_method ? @class_methods : @methods)[owner.name][node.name] = true
+          if class_method && node.name == :visible?
+            @visible_definitions << VisibleDefinition.new(class_name: owner.name, path: source_file.path,
+                                                          line: node.location.start_line)
+          end
+        end
+      end
+
+      def resolve_superclass(name)
+        superclass = @superclasses[name]
+        return "" unless superclass
+        return normalize(superclass) if superclass.include?("::")
+
+        namespace = name.split("::")[0...-1]
+        while namespace.any?
+          candidate = (namespace + [superclass]).join("::")
+          return candidate if @superclasses.key?(candidate) || direct_kind(candidate)
+
+          namespace.pop
+        end
+        superclass
+      end
+
+      def owner_for(entries, node)
+        entries.select do |entry|
+          node.location.start_offset > entry.start_offset && node.location.end_offset < entry.end_offset
+        end.min_by { |entry| entry.end_offset - entry.start_offset }
+      end
+
+      def nested_in?(scope, node)
+        node.location.start_offset > scope.location.start_offset && node.location.end_offset < scope.location.end_offset
+      end
+
+      def first_argument(call) = (arg = call.arguments&.arguments&.first) && (constant_name(arg) || arg.location.slice)
+
+      def direct_kind(name)
+        DIRECT_KINDS[name] || @configured_kinds[name] || (@interface_names[name] && :interface) ||
+          SUFFIX_KINDS.find { |suffix, _kind| name.end_with?(suffix) }&.last
+      end
+
+      def ancestors(class_name)
+        name = normalize(class_name)
+        result = []
+        seen = {}
+        until name.empty? || seen[name]
+          result << name
+          seen[name] = true
+          name = resolve_superclass(name)
+        end
+        result
+      end
+
+      def qualify(name, parent_name)
+        normalized = normalize(name)
+        return normalized if normalized.include?("::") || !parent_name
+
+        "#{parent_name}::#{normalized}"
+      end
+
+      def constant_name(node)
+        return node.name.to_s if node.is_a?(Prism::ConstantReadNode)
+
+        node.location.slice.delete_prefix("::") if node.is_a?(Prism::ConstantPathNode)
+      end
+
+      def normalize(name) = name.to_s.delete_prefix("::")
+    end
+  end
+end

data/lib/graphql/modernize/cli.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "pathname"
+
+module GraphQL
+  module Modernize
+    class CLI
+      COMMANDS = %w[run list explain doctor version].freeze
+      PACKAGE_ROOT = File.expand_path("../../..", __dir__)
+
+      def self.start(arguments = ARGV, out: $stdout, err: $stderr)
+        new(arguments.dup, out: out, err: err).start
+      end
+
+      def initialize(arguments, out:, err:)
+        @arguments = arguments
+        @out = out
+        @err = err
+      end
+
+      def start
+        command = COMMANDS.include?(@arguments.first) ? @arguments.shift : "run"
+        public_send(command)
+      rescue StandardError => e
+        @err.puts("graphql-modernize: #{e.message}")
+        2
+      end
+
+      def run
+        options = { diff: true, format: "text", jobs: Etc.nprocessors, force: false, strict: false }
+        parser = run_parser(options)
+        paths = catch(:help) { parser.parse(@arguments) }
+        return 0 if paths == :help
+
+        config = Config.load(root: Dir.pwd, overrides: config_overrides(options))
+        rules = selected_rules(options, config)
+        application = Application.new(config: config, rules: rules, jobs: options[:jobs],
+                                      explicit_rule_ids: options[:only] || [])
+        application.ensure_write_safe!(paths: paths, force: options[:force]) if options[:write]
+        result = application.run(paths)
+        warn_parse_errors(result) unless %w[text json].include?(options[:format])
+        output = Reporter.render(options[:format], result, diff: options[:diff])
+        if options[:out]
+          ensure_output_is_not_source!(options[:out], result)
+          File.write(options[:out], output)
+        else
+          @out.write(output)
+        end
+        strict_failure = options[:strict] && result.parse_errors.any?
+        application.write(result) if options[:write] && !strict_failure
+        return 2 if strict_failure
+
+        unresolved?(result, options[:fail_level]) ? 1 : 0
+      end
+
+      def list
+        parse_no_options("list")
+        RuleRegistry.all.each do |rule|
+          metadata = rule.metadata
+          @out.puts("#{metadata.id}\t#{metadata.safety}\t#{metadata.summary}")
+        end
+        0
+      end
+
+      def explain
+        parser = OptionParser.new { |opts| opts.banner = "Usage: graphql-modernize explain RULE_ID" }
+        parser.parse!(@arguments)
+        raise Error, "Specify exactly one RULE_ID" unless @arguments.one?
+
+        metadata = RuleRegistry.fetch(@arguments.first).metadata
+        @out.puts("#{metadata.id}: #{metadata.summary}")
+        @out.puts("safety: #{metadata.safety}")
+        @out.puts("since: #{metadata.since}") if metadata.since
+        @out.puts("removed_in: #{metadata.removed_in}") if metadata.removed_in
+        docs = metadata.docs && File.expand_path(metadata.docs, PACKAGE_ROOT)
+        @out.puts("\n#{File.read(docs)}") if docs && File.file?(docs)
+        0
+      end
+
+      def doctor
+        parse_no_options("doctor")
+        config = Config.load(root: Dir.pwd)
+        files = FileFinder.new(config).find
+        @out.puts("configuration: ok")
+        @out.puts("ruby: #{RUBY_VERSION}")
+        @out.puts("astel: #{Astel::VERSION}")
+        @out.puts("graphql: #{config.from_version || 'unknown'} -> #{config.target_version || 'unknown'}")
+        @out.puts("files: #{files.length}")
+        0
+      end
+
+      def version
+        parse_no_options("version")
+        @out.puts(GraphQL::Modernize::VERSION)
+        0
+      end
+
+      private
+
+      def run_parser(options)
+        OptionParser.new do |opts|
+          opts.banner = "Usage: graphql-modernize run [PATHS...] [options]"
+          opts.on("--write", "Rewrite files") { options[:write] = true }
+          opts.on("--[no-]diff", "Print a diff") { |value| options[:diff] = value }
+          opts.on("--only IDS", Array, "Run only the specified rules") { |value| options[:only] = value }
+          opts.on("--except IDS", Array, "Exclude the specified rules") { |value| options[:except] = value }
+          opts.on("--target-version VERSION") { |value| options[:target_version] = value }
+          opts.on("--from-version VERSION") { |value| options[:from_version] = value }
+          opts.on("--ruby-version VERSION") { |value| options[:ruby_version] = value }
+          opts.on("--unsafe", "Apply unsafe corrections") { options[:apply_unsafe] = true }
+          opts.on("--iterations N", Integer) { |value| options[:iterations] = value }
+          opts.on("--format FORMAT", %w[text diff json github sarif]) { |value| options[:format] = value }
+          opts.on("--out PATH") { |value| options[:out] = value }
+          opts.on("--jobs N", Integer) { |value| options[:jobs] = value }
+          opts.on("--strict") { options[:strict] = true }
+          opts.on("--force") { options[:force] = true }
+          opts.on("--fail-level LEVEL", %w[any manual unsafe none]) { |value| options[:fail_level] = value }
+          opts.on("--no-color") { options[:no_color] = true }
+          opts.on("-h", "--help") do
+            @out.puts(opts)
+            throw :help, :help
+          end
+        end
+      end
+
+      def config_overrides(options)
+        options.slice(:target_version, :from_version, :ruby_version, :apply_unsafe, :iterations)
+      end
+
+      def selected_rules(options, config)
+        rules = options[:only] ? options[:only].map { |id| RuleRegistry.fetch(id) }.uniq : RuleRegistry.all
+        excluded = Array(options[:except]).map { |id| RuleRegistry.fetch(id).metadata.id }
+        rules = rules.reject { |rule| excluded.include?(rule.metadata.id) }
+        return rules unless config.target_version
+
+        target = Gem::Version.new(config.target_version)
+        rules.select do |rule|
+          boundary = rule.metadata.since || rule.metadata.removed_in
+          !boundary || target >= Gem::Version.new(boundary)
+        end
+      end
+
+      def ensure_output_is_not_source!(output_path, result)
+        output = File.expand_path(output_path)
+        conflict = result.files.any? do |file|
+          source = File.expand_path(file.source_file.path)
+          output == source || (File.exist?(output) && File.identical?(output, source))
+        end
+        raise Error, "--out must differ from every input file" if conflict
+      end
+
+      def warn_parse_errors(result)
+        result.parse_errors.each do |path, errors|
+          @err.puts("#{path}: parse error: #{errors.join(', ')}")
+        end
+      end
+
+      def unresolved?(result, fail_level)
+        offenses = result.files.flat_map(&:offenses).reject(&:corrected?)
+        case fail_level || "any"
+        when "none" then false
+        when "manual" then offenses.any? { |offense| offense.safety == :manual }
+        when "unsafe" then offenses.any? { |offense| %i[manual unsafe].include?(offense.safety) }
+        else offenses.any?
+        end
+      end
+
+      def parse_no_options(command)
+        OptionParser.new { |opts| opts.banner = "Usage: graphql-modernize #{command}" }.parse!(@arguments)
+        raise Error, "Unexpected arguments: #{@arguments.join(' ')}" unless @arguments.empty?
+      end
+    end
+  end
+end