graphql-modernize 0.1.0

data/lib/graphql/modernize/config.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module GraphQL
+  module Modernize
+    class Config
+      DEFAULT_INCLUDE = ["app/graphql/**/*.rb", "lib/graphql/**/*.rb"].freeze
+      DEFAULT_EXCLUDE = ["vendor/**/*", "tmp/**/*"].freeze
+      BASE_CLASS_KINDS = %w[object input_object enum interface union resolver mutation subscription schema].freeze
+      DEFAULTS = {
+        "include" => DEFAULT_INCLUDE,
+        "exclude" => DEFAULT_EXCLUDE,
+        "base_classes" => {},
+        "rules" => {},
+        "apply_unsafe" => false,
+        "require_suppression_reason" => false,
+        "iterations" => 3
+      }.freeze
+      KEYS = (DEFAULTS.keys + %w[from_version target_version ruby_version]).freeze
+
+      attr_reader :root, :include_patterns, :exclude_patterns, :base_classes, :rules,
+                  :ruby_version, :apply_unsafe, :from_version, :target_version,
+                  :require_suppression_reason, :iterations
+
+      def self.load(root: Dir.pwd, path: nil, overrides: {})
+        root = File.expand_path(root)
+        path ||= File.join(root, ".graphql-modernize.yml")
+        file_options = File.file?(path) ? YAML.safe_load_file(path, aliases: false) : {}
+        raise Error, "The configuration root must be a mapping" unless file_options.nil? || file_options.is_a?(Hash)
+
+        options = DEFAULTS.merge(file_options || {}).merge(overrides.compact.transform_keys(&:to_s))
+        unknown = options.keys - KEYS
+        raise Error, "Unknown configuration keys: #{unknown.join(', ')}" unless unknown.empty?
+
+        new(root: root, include_patterns: options["include"], exclude_patterns: options["exclude"],
+            base_classes: options["base_classes"], rules: options["rules"], ruby_version: options["ruby_version"],
+            apply_unsafe: options["apply_unsafe"], from_version: options["from_version"],
+            target_version: options["target_version"],
+            require_suppression_reason: options["require_suppression_reason"], iterations: options["iterations"])
+      rescue Psych::Exception => e
+        raise Error, "Unable to load the configuration file: #{e.message}"
+      end
+
+      def initialize(root: Dir.pwd, include_patterns: DEFAULT_INCLUDE, exclude_patterns: DEFAULT_EXCLUDE,
+                     base_classes: {}, rules: {}, ruby_version: nil, apply_unsafe: false, from_version: nil,
+                     target_version: nil, require_suppression_reason: false, iterations: 3)
+        validate!(include_patterns, exclude_patterns, base_classes, rules, apply_unsafe,
+                  require_suppression_reason, iterations, ruby_version, from_version, target_version)
+
+        @root = File.expand_path(root)
+        @include_patterns = Array(include_patterns).freeze
+        @exclude_patterns = Array(exclude_patterns).freeze
+        @base_classes = base_classes.transform_keys(&:to_sym).transform_values { |names| Array(names) }.freeze
+        @rules = rules.to_h { |id, options| [id.to_s.upcase, options.transform_keys(&:to_s).freeze] }.freeze
+        @ruby_version = ruby_version
+        @apply_unsafe = apply_unsafe
+        @from_version = from_version || locked_graphql_version
+        @target_version = target_version || locked_graphql_version
+        if @from_version && @target_version && Gem::Version.new(@from_version) > Gem::Version.new(@target_version)
+          raise Error, "from_version must be less than or equal to target_version"
+        end
+
+        @require_suppression_reason = require_suppression_reason
+        @iterations = iterations
+      rescue ArgumentError => e
+        raise Error, "Invalid version configuration: #{e.message}"
+      end
+
+      def rule_enabled?(metadata)
+        configured = rules.fetch(metadata.id, {})
+        configured.fetch("enabled", metadata.default_enabled)
+      end
+
+      def rule_options(rule_id)
+        rules.fetch(rule_id, {})
+      end
+
+      private
+
+      def validate!(include_patterns, exclude_patterns, base_classes, rules, apply_unsafe,
+                    require_suppression_reason, iterations, ruby_version, from_version, target_version)
+        unless iterations.is_a?(Integer) && iterations.positive?
+          raise Error, "iterations must be an integer greater than or equal to 1"
+        end
+        raise Error, "base_classes must be a mapping" unless base_classes.is_a?(Hash)
+        raise Error, "rules must be a mapping" unless rules.is_a?(Hash)
+        unless [true, false].include?(apply_unsafe) && [true, false].include?(require_suppression_reason)
+          raise Error, "Boolean settings must be true or false"
+        end
+        unless include_patterns.is_a?(Array) && exclude_patterns.is_a?(Array) &&
+               include_patterns.all?(String) && exclude_patterns.all?(String)
+          raise Error, "include and exclude must be arrays of strings"
+        end
+        raise Error, "Each rule configuration must be a mapping" unless rules.values.all?(Hash)
+        unless base_classes.values.all? { |names| names.is_a?(Array) && names.all?(String) }
+          raise Error, "Each base_classes value must be an array of class-name strings"
+        end
+        if base_classes.values.flatten.any? { |name| name.strip.empty? }
+          raise Error, "base_classes class names must not be empty"
+        end
+
+        unknown_kinds = base_classes.keys.map(&:to_s) - BASE_CLASS_KINDS
+        raise Error, "Unknown base_classes kinds: #{unknown_kinds.join(', ')}" unless unknown_kinds.empty?
+
+        validate_rules!(rules)
+        validate_versions!(ruby_version, from_version, target_version)
+      end
+
+      def validate_rules!(rules)
+        known_rules = RuleRegistry.all.map { |rule| rule.metadata.id }
+        unknown_rules = rules.keys.map { |id| id.to_s.upcase } - known_rules
+        raise Error, "Unknown rule IDs: #{unknown_rules.join(', ')}" unless unknown_rules.empty?
+
+        rules.each do |id, options|
+          allowed = id.to_s.upcase == "GQLM307" ? %w[enabled migration_errors] : %w[enabled]
+          unknown_options = options.keys.map(&:to_s) - allowed
+          raise Error, "Unknown settings for #{id}: #{unknown_options.join(', ')}" unless unknown_options.empty?
+        end
+        validate_rule_values!(rules)
+      end
+
+      def validate_rule_values!(rules)
+        valid_enabled = rules.values.all? do |options|
+          key = options.key?("enabled") ? "enabled" : :enabled
+          !options.key?(key) || [true, false].include?(options[key])
+        end
+        raise Error, "A rule's enabled setting must be true or false" unless valid_enabled
+
+        visibility_options = rules.find { |id, _options| id.to_s.upcase == "GQLM307" }&.last || {}
+        migration_errors = visibility_options.fetch("migration_errors",
+                                                    visibility_options.fetch(:migration_errors, true))
+        return if [true, false].include?(migration_errors)
+
+        raise Error, "GQLM307 migration_errors must be true or false"
+      end
+
+      def validate_versions!(ruby_version, from_version, target_version)
+        if ruby_version && (!ruby_version.is_a?(String) || !ruby_version.match?(/\A\d+\.\d+(?:\.\d+)?\z/))
+          raise Error, "ruby_version must use the X.Y format"
+        end
+
+        [from_version, target_version].compact.each do |version|
+          raise Error, "versions must be strings" unless version.is_a?(String)
+          raise Error, "versions must not be empty" if version.strip.empty?
+
+          Gem::Version.new(version)
+        end
+      end
+
+      def locked_graphql_version
+        lockfile = File.join(root, "Gemfile.lock")
+        return unless File.file?(lockfile)
+
+        File.foreach(lockfile) do |line|
+          match = line.match(/^    graphql \((\d+(?:\.\d+)+)/)
+          return match[1] if match
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/modernize/context_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    Context = Data.define(:class_stack, :superclass, :graphql_kind, :class_name, :class_node)
+
+    class ContextBuilder
+      def initialize(source_file, hierarchy)
+        nodes = {}
+        scopes = []
+        @call_receivers = {}.compare_by_identity
+        @argument_calls = {}.compare_by_identity
+        @top_level_statements = {}.compare_by_identity
+        source_file.ast.statements.body.each { |node| @top_level_statements[node] = true }
+        # ponytail: nested calls rescan descendants; add a parent index only if deep DSLs become a bottleneck.
+        record_arguments = lambda do |call|
+          stack = call.arguments&.arguments&.dup || []
+          until stack.empty?
+            argument = stack.pop
+            @argument_calls[argument] = call
+            stack.concat(argument.compact_child_nodes)
+          end
+        end
+        dispatcher = Astel::Dispatcher.new
+        callback = ->(node) { nodes[node.location.start_offset] = node }
+        dispatcher.on(:class_node, callback)
+        dispatcher.on(:module_node, callback)
+        dispatcher.on(:def_node) { |node| scopes << node }
+        dispatcher.on(:lambda_node) { |node| scopes << node }
+        dispatcher.on(:call_node) do |node|
+          @call_receivers[node.receiver] = true if node.receiver
+          record_arguments.call(node)
+          scopes << node.block if node.block && (node.receiver || node.name != :field)
+        end
+        dispatcher.run(source_file.ast)
+        @executable_scopes = scopes.map do |scope|
+          [scope.location.start_offset, scope.location.end_offset]
+        end.sort_by(&:first)
+
+        @ranges = hierarchy.declarations.fetch(source_file.path, {}).values.map do |declaration|
+          context = Context.new(
+            class_stack: declaration.name.split("::"),
+            superclass: declaration.superclass,
+            graphql_kind: hierarchy.resolve_kind(declaration.name),
+            class_name: declaration.name,
+            class_node: nodes[declaration.start_offset]
+          )
+          [declaration.start_offset, declaration.end_offset, context]
+        end.sort_by(&:first)
+      end
+
+      def context_at(byte_offset)
+        index = @ranges.bsearch_index { |start_offset, _end_offset, _context| start_offset > byte_offset }
+        index = index ? index - 1 : @ranges.length - 1
+        index.downto(0) do |candidate|
+          start_offset, end_offset, context = @ranges[candidate]
+          return context if byte_offset >= start_offset && byte_offset < end_offset
+        end
+        nil
+      end
+
+      def executable_scope_at?(byte_offset)
+        index = @executable_scopes.bsearch_index { |start_offset, _end_offset| start_offset >= byte_offset }
+        index = index ? index - 1 : @executable_scopes.length - 1
+        index.downto(0).any? do |candidate|
+          start_offset, end_offset = @executable_scopes[candidate]
+          byte_offset > start_offset && byte_offset < end_offset
+        end
+      end
+
+      def call_receiver?(node) = @call_receivers.key?(node)
+
+      def argument_call(node) = @argument_calls[node]
+
+      def top_level_statement?(node) = @top_level_statements.key?(node)
+    end
+  end
+end

data/lib/graphql/modernize/file_finder.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module GraphQL
+  module Modernize
+    class FileFinder
+      def initialize(config)
+        @config = config
+      end
+
+      def find(paths = [])
+        candidates = paths.empty? ? configured_files : explicit_files(paths)
+        candidates.select { |path| File.file?(path) && path.end_with?(".rb") }
+                  .reject { |path| excluded?(path) }.uniq.sort
+      end
+
+      private
+
+      attr_reader :config
+
+      def configured_files
+        config.include_patterns.flat_map { |pattern| Dir.glob(File.join(config.root, pattern)) }
+      end
+
+      def explicit_files(paths)
+        paths.flat_map do |path|
+          absolute = File.expand_path(path, config.root)
+          if File.directory?(absolute)
+            Dir.glob(File.join(absolute, "**/*.rb"))
+          elsif File.file?(absolute) && absolute.end_with?(".rb")
+            absolute
+          else
+            raise Error, "Input path does not exist or is not a Ruby file: #{path}"
+          end
+        end
+      end
+
+      def excluded?(path)
+        relative = Pathname.new(path).relative_path_from(Pathname.new(config.root)).to_s
+        config.exclude_patterns.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+      end
+    end
+  end
+end

data/lib/graphql/modernize/offense.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    class Offense
+      attr_reader :rule_id, :location, :message, :safety, :path
+      attr_accessor :corrected, :conflicting_rule_id
+
+      def initialize(rule_id:, location:, message:, safety:, path:, correctable:)
+        @rule_id = rule_id
+        @location = location
+        @message = message
+        @safety = safety
+        @path = path
+        @correctable = correctable
+        @corrected = false
+      end
+
+      def correctable?
+        @correctable
+      end
+
+      def corrected?
+        corrected
+      end
+    end
+  end
+end

data/lib/graphql/modernize/reporter.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+
+module GraphQL
+  module Modernize
+    module Reporter
+      module_function
+
+      def render(format, result, diff: true)
+        case format.to_s
+        when "text" then text(result, diff: diff)
+        when "diff" then diffs(result)
+        when "json" then JSON.pretty_generate(payload(result)) << "\n"
+        when "github" then github(result)
+        when "sarif" then JSON.pretty_generate(sarif_payload(result)) << "\n"
+        else raise Error, "Unknown output format: #{format}"
+        end
+      end
+
+      def text(result, diff: true)
+        offenses = result.files.flat_map(&:offenses)
+        output = result.parse_errors.map do |path, errors|
+          "#{path}: parse error: #{errors.join(', ')}"
+        end.join("\n")
+        output << "\n" unless output.empty?
+        offense_output = offenses.map do |offense|
+          status = offense.corrected? ? " corrected" : ""
+          conflict = offense.conflicting_rule_id ? " conflicts_with=#{offense.conflicting_rule_id}" : ""
+          "#{offense.path}:#{offense.location.start_line}:#{offense.location.start_column + 1}: " \
+            "[#{offense.rule_id}]#{status}#{conflict} #{offense.message}"
+        end.join("\n")
+        output << offense_output
+        output << "\n" unless output.empty?
+        output << diffs(result) if diff
+        changed = result.files.count { |file| file.source_file.source != file.rewritten }
+        output << "#{result.files.length} files inspected, #{offenses.length} offenses, #{changed} files changed\n"
+      end
+
+      def diffs(result)
+        result.files.filter_map do |file|
+          next if file.source_file.source == file.rewritten
+
+          Astel::Diff.unified(file.source_file.source, file.rewritten, path: relative_path(file.source_file.path))
+        end.join
+      end
+
+      def github(result)
+        result.files.flat_map(&:offenses).map do |offense|
+          message = escape(offense.message)
+          "::warning file=#{escape(offense.path)},line=#{offense.location.start_line}," \
+            "col=#{offense.location.start_column + 1},title=#{offense.rule_id}::#{message}"
+        end.join("\n") << (result.files.any? { |file| file.offenses.any? } ? "\n" : "")
+      end
+
+      def payload(result)
+        {
+          files: result.files.length,
+          iterations: result.iterations,
+          parse_errors: result.parse_errors.map { |path, errors| { path: path, errors: errors } },
+          offenses: result.files.flat_map(&:offenses).map { |offense| offense_payload(offense) }
+        }
+      end
+
+      def sarif_payload(result)
+        offenses = result.files.flat_map(&:offenses)
+        rules = offenses.uniq(&:rule_id).map do |offense|
+          { id: offense.rule_id, shortDescription: { text: offense.message } }
+        end
+        results = offenses.map do |offense|
+          {
+            ruleId: offense.rule_id,
+            message: { text: offense.message },
+            locations: [{ physicalLocation: {
+              artifactLocation: { uri: offense.path },
+              region: { startLine: offense.location.start_line, startColumn: offense.location.start_column + 1 }
+            } }]
+          }
+        end
+        { version: "2.1.0", "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+          runs: [{ tool: { driver: { name: "graphql-modernize", rules: rules } }, results: results }] }
+      end
+
+      def offense_payload(offense)
+        { rule_id: offense.rule_id, path: offense.path, line: offense.location.start_line,
+          column: offense.location.start_column + 1, message: offense.message, safety: offense.safety,
+          correctable: offense.correctable?, corrected: offense.corrected?,
+          conflicting_rule_id: offense.conflicting_rule_id }
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+      rescue ArgumentError
+        path
+      end
+
+      def escape(value)
+        value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A").gsub(":", "%3A").gsub(",", "%2C")
+      end
+    end
+  end
+end

data/lib/graphql/modernize/rule_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module RuleRegistry
+      @rules = {}
+
+      module_function
+
+      def register(rule_class)
+        id = rule_class.metadata.id
+        raise ArgumentError, "duplicate rule id: #{id}" if @rules.key?(id)
+
+        @rules[id] = rule_class
+      end
+
+      def all
+        @rules.values.sort_by { |rule_class| rule_class.metadata.id }
+      end
+
+      def fetch(id)
+        @rules.fetch(id.to_s.upcase) { raise ArgumentError, "unknown rule: #{id}" }
+      end
+    end
+  end
+end

data/lib/graphql/modernize/rules/base.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Modernize
+    module Rules
+      Metadata = Data.define(:id, :safety, :summary, :since, :removed_in, :docs, :default_enabled)
+      Pattern = Data.define(:node_type, :compiled, :handler)
+
+      class Base
+        class << self
+          attr_reader :metadata, :patterns
+
+          def rule(id:, safety:, summary:, since: nil, removed_in: nil, docs: nil, default_enabled: true)
+            raise ArgumentError, "invalid rule id: #{id}" unless id.match?(/\AGQLM\d{3}\z/)
+            raise ArgumentError, "invalid safety: #{safety}" unless %i[safe unsafe manual].include?(safety)
+
+            @metadata = Metadata.new(id: id, safety: safety, summary: summary, since: since,
+                                     removed_in: removed_in, docs: docs, default_enabled: default_enabled)
+            RuleRegistry.register(self)
+          end
+
+          def node_pattern(node_type, pattern_source, handler: :on_match)
+            @patterns ||= []
+            @patterns << Pattern.new(node_type: node_type.to_sym,
+                                     compiled: Astel::NodePattern.compile(pattern_source), handler: handler)
+          end
+
+          def node_types
+            (@patterns || []).map(&:node_type).uniq
+          end
+        end
+
+        attr_reader :offenses
+
+        def initialize(context:, rewriter:, config:, suppression: nil, hierarchy: nil, edit_rules: {})
+          @context = context
+          @rewriter = rewriter
+          @config = config
+          @suppression = suppression
+          @hierarchy = hierarchy
+          @edit_rules = edit_rules
+          @offenses = []
+        end
+
+        def visit(node)
+          self.class.patterns.each do |pattern|
+            next unless pattern.node_type == Astel::NodeType.from_class_name(node.class.name.split("::").last)
+
+            captures = pattern.compiled.match(node)
+            send(pattern.handler, node, captures) if captures
+          end
+        end
+
+        private
+
+        attr_reader :rewriter, :config, :hierarchy
+
+        def add_offense(location, message:, safety: self.class.metadata.safety, &correction)
+          return if @suppression&.suppressed?(self.class.metadata.id, location)
+
+          offense = Offense.new(rule_id: self.class.metadata.id, location: location, message: message,
+                                safety: safety, path: rewriter.source_file.path,
+                                correctable: !correction.nil?)
+          @offenses << offense
+          return offense unless correction && correction_enabled?(safety)
+
+          edit_count = rewriter.edits.length
+          offense.corrected = rewriter.transaction(raise_on_conflict: true) { |rw| correction.call(rw) }
+          rewriter.edits.drop(edit_count).each { |edit| @edit_rules[edit] = self.class.metadata.id }
+          offense
+        rescue Astel::Rewriter::ConflictError => e
+          offense.conflicting_rule_id = @edit_rules.fetch(e.conflicting_edit, self.class.metadata.id)
+          offense
+        end
+
+        def correction_enabled?(safety)
+          safety == :safe || (safety == :unsafe && config.apply_unsafe)
+        end
+
+        def context_for(node)
+          @context.context_at(node.location.start_offset)
+        end
+
+        def graphql_kind(node)
+          context_for(node)&.graphql_kind
+        end
+
+        def inside?(node, *kinds)
+          context = context_for(node)
+          kinds.include?(context&.graphql_kind) && !ClassHierarchy::DIRECT_KINDS.key?(context.class_name) &&
+            !@context.executable_scope_at?(node.location.start_offset)
+        end
+
+        def standalone_line?(node)
+          source = rewriter.source_file
+          line_start = source.line_start(node.location.start_offset)
+          line_end = source.line_end([node.location.end_offset - 1, node.location.start_offset].max)
+          before = source.source.byteslice(line_start, node.location.start_offset - line_start)
+          after = source.source.byteslice(node.location.end_offset, line_end - node.location.end_offset).lstrip
+          before.strip.empty? && after.empty?
+        end
+
+        def safe_to_discard?(node)
+          node.static_literal?
+        end
+
+        def keyword_arguments(node, name)
+          keyword_hashes(node).flat_map(&:elements).select do |argument|
+            argument.is_a?(Prism::AssocNode) && argument.key.is_a?(Prism::SymbolNode) &&
+              argument.key.unescaped.to_sym == name
+          end
+        end
+
+        def dynamic_keyword_arguments?(node)
+          keyword_hashes(node).any? { |hash| hash.elements.any?(Prism::AssocSplatNode) }
+        end
+
+        def keyword_hashes(node) = node.arguments&.arguments&.grep(Prism::KeywordHashNode).to_a
+
+        def constant_source(node)
+          source = node&.location&.slice
+          source&.delete_prefix("::")
+        end
+
+        def replace_constant(rewriter, node, replacement)
+          prefix = node.location.slice.start_with?("::") ? "::" : ""
+          rewriter.replace(node.location, "#{prefix}#{replacement}")
+        end
+      end
+    end
+  end
+end