rubocop-isucon 0.1.0 → 1.0.0

data/lib/rubocop/cop/isucon/mixin/n_plus_one_query_methods.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::NPlusOneQuery}
+        # and {RuboCop::Cop::Isucon::Sqlite3::NPlusOneQuery}
+        module NPlusOneQueryMethods
+          include Mixin::DatabaseMethods
+
+          extend NodePattern::Macros
+
+          MSG = "This looks like N+1 query."
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L38
+          POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L39
+          LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L41
+          ENUMERABLE_METHOD_NAMES = (Enumerable.instance_methods + [:each]).to_set.freeze
+
+          def_node_matcher :csv_loop?, <<~PATTERN
+            (block
+              (send (const nil? :CSV) :parse ...)
+              ...)
+          PATTERN
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L68
+          def_node_matcher :kernel_loop?, <<~PATTERN
+            (block
+              (send {nil? (const nil? :Kernel)} :loop)
+              ...)
+          PATTERN
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L74
+          def_node_matcher :enumerable_loop?, <<~PATTERN
+            (block
+              (send $_ #enumerable_method? ...)
+              ...)
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_error_handling(node) do
+              with_db_query(node) do |type, root_gda|
+                check_and_register_offence(node: node, type: type, root_gda: root_gda, is_array_arg: array_arg?)
+              end
+            end
+          end
+
+          private
+
+          # @param node [RuboCop::AST::Node]
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param is_array_arg [Boolean]
+          def check_and_register_offence(node:, type:, root_gda:, is_array_arg:) # rubocop:disable Metrics/MethodLength
+            return unless db_query_node?(node)
+
+            receiver, = *node.children
+
+            parent = parent_loop_node(receiver)
+            return unless parent
+
+            return if or_assignment_to_instance_variable?(node)
+
+            add_offense(receiver) do |corrector|
+              perform_autocorrect(
+                corrector: corrector, current_node: receiver,
+                parent_node: parent, type: type, gda: root_gda, is_array_arg: is_array_arg
+              )
+            end
+          end
+
+          # @param node [RuboCop::AST::Node]
+          def db_query_node?(node)
+            return db_query_methods.include?(node.children[1]) if node.children.count >= 3
+
+            child = node.children.first
+            return false unless child
+
+            child.children.count >= 3 && db_query_methods.include?(child.children[1])
+          end
+
+          # Whether match to `@instance_var ||=`
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def or_assignment_to_instance_variable?(node)
+            _or_assignment_to_instance_variable?(node.parent&.parent) ||
+              _or_assignment_to_instance_variable?(node.parent&.parent&.parent)
+          end
+
+          # Whether match to `@instance_var ||=`
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def _or_assignment_to_instance_variable?(node)
+            node&.or_asgn_type? && node.child_nodes&.first&.ivasgn_type?
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @return [RuboCop::AST::Node]
+          def parent_loop_node(node)
+            node.each_ancestor.find { |ancestor| loop?(ancestor, node) }
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L106
+          def loop?(ancestor, node)
+            keyword_loop?(ancestor.type) ||
+              kernel_loop?(ancestor) ||
+              node_within_enumerable_loop?(node, ancestor) ||
+              csv_loop?(ancestor)
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L112
+          def keyword_loop?(type)
+            LOOP_TYPES.include?(type)
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L116
+          def node_within_enumerable_loop?(node, ancestor)
+            enumerable_loop?(ancestor) do |receiver|
+              receiver != node && !receiver&.descendants&.include?(node)
+            end
+          end
+
+          # @see https://github.com/rubocop/rubocop-performance/blob/v1.11.5/lib/rubocop/cop/performance/collection_literal_in_loop.rb#L130
+          def enumerable_method?(method_name)
+            ENUMERABLE_METHOD_NAMES.include?(method_name)
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param current_node [RuboCop::AST::Node]
+          # @param parent_node [RuboCop::AST::Node]
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param is_array_arg [Boolean]
+          def perform_autocorrect(corrector:, current_node:, parent_node:, type:, gda:, is_array_arg:) # rubocop:disable Metrics/ParameterLists
+            return unless enabled_database?
+
+            corrector = Correctors::NPlusOneQueryCorrector.new(
+              corrector: corrector, current_node: current_node, is_array_arg: is_array_arg,
+              parent_node: parent_node, type: type, gda: gda, connection: connection
+            )
+            corrector.correct
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/offense_location_methods.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Calculate offense location from Ruby and SQL ASTs
+        module OffenceLocationMethods
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param node [RuboCop::AST::Node]
+          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
+          # @return [Parser::Source::Range,nil]
+          def offense_location(type:, node:, gda_location:)
+            return nil unless gda_location
+
+            begin_pos = begin_position_from_gda_location(type: type, node: node, gda_location: gda_location)
+            return nil unless begin_pos
+
+            end_pos = begin_pos + gda_location.length
+            Parser::Source::Range.new(node.loc.expression.source_buffer, begin_pos, end_pos)
+          end
+
+          private
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param node [RuboCop::AST::Node]
+          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
+          # @return [Integer,nil]
+          def begin_position_from_gda_location(type:, node:, gda_location:)
+            case type
+            when :str
+              return begin_position_from_gda_location_for_str(node: node, gda_location: gda_location)
+            when :dstr
+              return begin_position_from_gda_location_for_dstr(node: node, gda_location: gda_location)
+            end
+
+            nil
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
+          # @return [Integer,nil]
+          def begin_position_from_gda_location_for_str(node:, gda_location:)
+            str_node = node.child_nodes[1]
+            return nil unless str_node&.str_type?
+
+            str_node.loc.begin.end_pos + gda_location.begin_pos
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
+          # @return [Integer,nil]
+          def begin_position_from_gda_location_for_dstr(node:, gda_location:)
+            dstr_node = node.child_nodes[1]
+            return nil unless dstr_node&.dstr_type?
+
+            str_node = find_str_node_from_gda_location(dstr_node: dstr_node, gda_location: gda_location)
+            index = str_node.value.index(gda_location.body)
+            return nil unless index
+
+            str_node_begin_pos(str_node) + index + heredoc_indent_level(node)
+          end
+
+          # @param str_node [RuboCop::AST::StrNode]
+          # @return [Integer]
+          def str_node_begin_pos(str_node)
+            begin_pos = str_node.loc.expression.begin_pos
+
+            # e.g.
+            #   db.xquery(
+            #     "SELECT * " \
+            #     "FROM users " \
+            #     "LIMIT 10"
+            #   )
+            return begin_pos + 1 if str_node.loc.expression.source_buffer.source[begin_pos] == '"'
+
+            begin_pos
+          end
+
+          # @param dstr_node [RuboCop::AST::DstrNode]
+          # @param gda_location [RuboCop::Isucon::GDA::NodeLocation]
+          # @return [RuboCop::AST::StrNode,nil]
+          def find_str_node_from_gda_location(dstr_node:, gda_location:)
+            return nil unless dstr_node
+
+            begin_pos = 0
+            dstr_node.child_nodes.each do |str_node|
+              return str_node if begin_pos <= gda_location.begin_pos && gda_location.begin_pos < begin_pos + str_node.value.length
+
+              begin_pos += str_node.value.length
+            end
+            nil
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @return [Integer]
+          def heredoc_indent_level(node)
+            dstr_node = node.child_nodes[1]
+            return 0 unless dstr_node&.dstr_type?
+
+            heredoc_indent_type = heredoc_indent_type(node)
+            return 0 unless heredoc_indent_type == "~"
+
+            heredoc_body = dstr_node.loc.heredoc_body.source
+            indent_level(heredoc_body)
+          end
+
+          # @param str [String]
+          # @return [Integer]
+          # @see https://github.com/rubocop/rubocop/blob/v1.21.0/lib/rubocop/cop/mixin/heredoc.rb#L23-L28
+          def indent_level(str)
+            indentations = str.lines.
+                           map { |line| line[/^\s*/] }.
+                           reject { |line| line.end_with?("\n") }
+            indentations.empty? ? 0 : indentations.min_by(&:size).size
+          end
+
+          # Returns '~', '-' or nil
+          #
+          # @param node [RuboCop::AST::Node]
+          # @return [String,nil] '~', '-' or `nil`
+          # @see https://github.com/rubocop/rubocop/blob/v1.21.0/lib/rubocop/cop/layout/heredoc_indentation.rb#L146-L149
+          def heredoc_indent_type(node)
+            node.source[/<<([~-])/, 1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/select_asterisk_methods.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::SelectAsterisk} and {RuboCop::Cop::Isucon::Sqlite3::SelectAsterisk}
+        module SelectAsteriskMethods
+          include Mixin::DatabaseMethods
+
+          MSG = "Use SELECT with column names. (e.g. `SELECT id, name FROM table_name`)"
+
+          TODO = "# TODO: Remove needless columns if necessary\n"
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_error_handling(node) do
+              with_db_query(node) do |type, root_gda|
+                check_and_register_offence(type: type, root_gda: root_gda, node: node)
+              end
+            end
+          end
+
+          private
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param node [RuboCop::AST::Node]
+          def check_and_register_offence(type:, root_gda:, node:)
+            return unless root_gda
+
+            root_gda.visit_all do |gda|
+              next unless gda.ast.respond_to?(:expr_list)
+
+              gda.ast.expr_list.each do |select_field_node|
+                check_and_register_offence_for_select_field_node(
+                  type: type, node: node, gda: gda,
+                  select_field_node: select_field_node
+                )
+              end
+            end
+          end
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param node [RuboCop::AST::Node]
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param select_field_node [GDA::Nodes::SelectField]
+          def check_and_register_offence_for_select_field_node(type:, node:, gda:, select_field_node:)
+            return unless select_field_node.respond_to?(:expr)
+
+            select_field = parse_select_field_node(select_field_node)
+
+            return unless select_field[:column_name] == "*"
+
+            loc = offense_location(type: type, node: node, gda_location: select_field_node.expr.location)
+            return unless loc
+
+            add_offense(loc) do |corrector|
+              perform_autocorrect(corrector: corrector, loc: loc, gda: gda, node: node,
+                                  select_table_name: select_field[:table_name])
+            end
+          end
+
+          # @param select_field_node [GDA::Nodes::SelectField]
+          # @return [Hash{Symbol => String}] table_name, column_name
+          def parse_select_field_node(select_field_node)
+            column_elements = select_field_node.expr.value.split(".", 2)
+
+            case column_elements.count
+            when 1
+              return { column_name: column_elements[0] }
+            when 2
+              return { table_name: column_elements[0], column_name: column_elements[1] }
+            end
+
+            {}
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param loc [Parser::Source::Range]
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param node [RuboCop::AST::Node]
+          # @param select_table_name [String,nil] table names included in the SELECT clause
+          def perform_autocorrect(corrector:, loc:, gda:, node:, select_table_name:)
+            return unless enabled_database?
+            return if gda.table_names.empty?
+
+            if select_table_name
+              return unless gda.table_names.include?(select_table_name)
+
+              replace_asterisk(corrector: corrector, loc: loc, table_name: select_table_name, table_prefix: true)
+            else
+              return unless gda.table_names.length == 1
+
+              replace_asterisk(corrector: corrector, loc: loc, table_name: gda.table_names[0], table_prefix: false)
+            end
+
+            insert_todo_comment(corrector: corrector, node: node)
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param loc [Parser::Source::Range]
+          # @param table_name [String]
+          # @param table_prefix [Boolean] Whether add table name to prefix (e.g. `users`.`name`)
+          def replace_asterisk(corrector:, loc:, table_name:, table_prefix:)
+            select_columns = columns_in_select_clause(table_name: table_name, table_prefix: table_prefix)
+            corrector.replace(loc, select_columns)
+          end
+
+          # @param table_name [String]
+          # @param table_prefix [Boolean] Whether add table name to prefix (e.g. `users`.`name`)
+          # @return [String]
+          def columns_in_select_clause(table_name:, table_prefix:)
+            column_names = connection.column_names(table_name)
+
+            column_names.map do |column|
+              if table_prefix
+                "`#{table_name}`.`#{column}`"
+              else
+                "`#{column}`"
+              end
+            end.join(", ")
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          def insert_todo_comment(corrector:, node:)
+            current_line = node.loc.expression.line
+            current_line_range = node.loc.expression.source_buffer.line_range(current_line)
+
+            indent = node_indent_level(node)
+            comment_line = (" " * indent) + TODO
+            corrector.insert_before(current_line_range, comment_line)
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @return [Integer]
+          def node_indent_level(node)
+            node.loc.expression.source_line =~ /^(\s+)/
+            return 0 unless Regexp.last_match(1)
+
+            Regexp.last_match(1).length
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/sqlite3_execute_methods.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Helper methods for `db.execute` in AST
+        module Sqlite3ExecuteMethods
+          extend NodePattern::Macros
+
+          include OffenceLocationMethods
+
+          # @!method find_xquery(node)
+          #   @param node [RuboCop::AST::Node]
+          def_node_search :find_execute, <<~PATTERN
+            (send _ {:execute | :get_first_row} (${str dstr lvar ivar cvar} $...) ...)
+          PATTERN
+
+          NON_STRING_WARNING_MSG = "Warning: non-string was passed to `execute` or `get_first_row` 1st argument. " \
+                                   "So argument doesn't parsed as SQL (%<file_path>s:%<line_num>d)"
+
+          # @param node [RuboCop::AST::Node]
+          # @yieldparam type [Symbol] Node type. one of `:str`, `:dstr`
+          # @yieldparam root_gda [RuboCop::Isucon::GDA::Client,nil]
+          #
+          # @note If arguments of `db.xquery` isn't string, `root_gda` is `nil`
+          def with_db_query(node)
+            find_execute(node) do |type, params|
+              sql = execute_param(type: type, params: params)
+
+              unless sql
+                warn format(NON_STRING_WARNING_MSG, file_path: processed_source.file_path, line_num: node.loc.expression.line)
+              end
+
+              root_gda = sql ? RuboCop::Isucon::GDA::Client.new(sql) : nil
+
+              yield type, root_gda
+            end
+          end
+
+          private
+
+          # @return [Array<Symbol>]
+          def db_query_methods
+            %i[execute get_first_row]
+          end
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param params [Array<RuboCop::AST::Node>]
+          # @return [String,nil]
+          def execute_param(type:, params:)
+            case type
+            when :str
+              return params[0]
+            when :dstr
+              if params.all? { |param| param.respond_to?(:value) }
+                # heredoc
+                return params.map(&:value).join
+              end
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mixin/where_without_index_methods.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Common methods for {RuboCop::Cop::Isucon::Mysql2::WhereWithoutIndex}
+        # and {RuboCop::Cop::Isucon::Sqlite3::WhereWithoutIndex}
+        module WhereWithoutIndexMethods
+          include Mixin::DatabaseMethods
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            with_error_handling(node) do
+              return unless enabled_database?
+
+              with_db_query(node) do |type, root_gda|
+                check_and_register_offence(type: type, root_gda: root_gda, node: node)
+              end
+            end
+          end
+
+          private
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @param node [RuboCop::AST::Node]
+          def check_and_register_offence(type:, root_gda:, node:)
+            return unless root_gda
+            return if exists_index_in_where_clause_columns?(root_gda)
+
+            register_offense(type: type, node: node, root_gda: root_gda)
+          end
+
+          # @param type [Symbol] Node type. one of `:str`, `:dstr`
+          # @param node [RuboCop::AST::Node]
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          def register_offense(type:, node:, root_gda:)
+            root_gda.visit_all do |gda|
+              next if gda.where_nodes.empty?
+
+              loc = offense_location(type: type, node: node, gda_location: gda.where_nodes.first.location)
+              next unless loc
+
+              message = offense_message(gda)
+              add_offense(loc, message: message)
+            end
+          end
+
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          def offense_message(gda)
+            column_name = gda.where_conditions[0].column_operand
+            table_name = find_table_name_from_column_name(table_names: gda.table_names, column_name: column_name)
+            generate_offense_message(table_name: table_name, column_name: column_name)
+          end
+
+          # @param root_gda [RuboCop::Isucon::GDA::Client]
+          # @return [Boolean]
+          def exists_index_in_where_clause_columns?(root_gda)
+            root_gda.visit_all do |gda|
+              gda.table_names.each do |table_name|
+                return true if covered_where_column_in_index?(gda: gda, table_name: table_name)
+                return true if covered_where_column_in_primary_key?(gda: gda, table_name: table_name)
+              end
+            end
+
+            false
+          end
+
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param table_name [String]
+          # @return [Boolean]
+          def covered_where_column_in_index?(gda:, table_name:)
+            indexes = connection.indexes(table_name)
+            index_first_columns = indexes.map { |index| index.columns[0] }
+
+            gda.where_conditions.any? do |condition|
+              index_first_columns.include?(condition.column_operand)
+            end
+          end
+
+          # @param gda [RuboCop::Isucon::GDA::Client]
+          # @param table_name [String]
+          # @return [Boolean]
+          def covered_where_column_in_primary_key?(gda:, table_name:)
+            primary_keys = connection.primary_keys(table_name)
+            return false if primary_keys.empty?
+
+            where_columns = gda.where_conditions.map(&:column_operand)
+            primary_keys.all? { |primary_key| where_columns.include?(primary_key) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/mysql2/join_without_index.rb

@@ -16,82 +16,19 @@ module RuboCop
         #   db.xquery('SELECT id, title FROM articles JOIN users ON users.id = articles.user_id')
         #
         class JoinWithoutIndex < Base
-          include Mixin::DatabaseMethods
           include Mixin::Mysql2XqueryMethods
+          include Mixin::JoinWithoutIndexMethods
 
           MSG = "This join clause doesn't seem to have an index. " \
                 "(e.g. `ALTER TABLE %<table_name>s ADD INDEX index_%<column_name>s (%<column_name>s)`)"
 
-          # @param node [RuboCop::AST::Node]
-          def on_send(node)
-            with_error_handling(node) do
-              return unless enabled_database?
-
-              with_xquery(node) do |type, root_gda|
-                check_and_register_offence(type: type, root_gda: root_gda, node: node)
-              end
-            end
-          end
-
           private
 
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param root_gda [RuboCop::Isucon::GDA::Client]
-          # @param node [RuboCop::AST::Node]
-          def check_and_register_offence(type:, root_gda:, node:)
-            return unless root_gda
-
-            root_gda.visit_all do |gda|
-              gda.join_conditions.each do |join_condition|
-                join_operand = join_operand_without_index(join_condition)
-                next unless join_operand
-
-                register_offense(type: type, node: node, join_operand: join_operand)
-              end
-            end
-          end
-
-          # @param join_condition [RuboCop::Isucon::GDA::JoinCondition]
-          # @return [RuboCop::Isucon::GDA::JoinOperand,nil]
-          def join_operand_without_index(join_condition)
-            join_condition.operands.each do |join_operand|
-              next unless join_operand.table_name
-
-              unless indexed_column?(table_name: join_operand.table_name, column_name: join_operand.column_name)
-                return join_operand
-              end
-            end
-
-            nil
-          end
-
           # @param table_name [String]
           # @param column_name [String]
-          # @return [Boolean]
-          def indexed_column?(table_name:, column_name:)
-            primary_keys = connection.primary_keys(table_name)
-
-            return true if primary_keys&.first == column_name
-
-            indexes = connection.indexes(table_name)
-            index_first_columns = indexes.map { |index| index.columns[0] }
-            index_first_columns.include?(column_name)
-          end
-
-          # @param type [Symbol] Node type. one of `:str`, `:dstr`
-          # @param node [RuboCop::AST::Node]
-          # @param join_operand [RuboCop::Isucon::GDA::JoinOperand]
-          def register_offense(type:, node:, join_operand:)
-            loc = offense_location(type: type, node: node, gda_location: join_operand.node.location)
-            return unless loc
-
-            message = offense_message(join_operand)
-            add_offense(loc, message: message)
-          end
-
-          # @param join_operand [RuboCop::Isucon::GDA::JoinOperand]
-          def offense_message(join_operand)
-            format(MSG, table_name: join_operand.table_name, column_name: join_operand.column_name)
+          # @return [String]
+          def generate_offense_message(table_name:, column_name:)
+            format(MSG, table_name: table_name, column_name: column_name)
           end
         end
       end