rubocop-isucon 0.1.0

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "rubocop/isucon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/default.yml

@@ -0,0 +1,83 @@
+Isucon/Mysql2:
+  StyleGuideBaseURL: https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Mysql2/
+  Database:
+
+Isucon/Mysql2/JoinWithoutIndex:
+  Description: 'Check for `JOIN` without index'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: JoinWithoutIndex.html
+
+Isucon/Mysql2/ManyJoinTable:
+  Description: 'Check if SQL contains many JOINs'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: ManyJoinTable.html
+  CountTables: 3
+
+Isucon/Mysql2/NPlusOneQuery:
+  Description: 'Checks that N+1 query is not used'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  SafeAutoCorrect: false
+  StyleGuide: NPlusOneQuery.html
+
+Isucon/Mysql2/PrepareExecute:
+  Description: 'Use `db.xquery` instead of `db.prepare`'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: PrepareExecute.html
+
+Isucon/Mysql2/SelectAsterisk:
+  Description: 'Avoid `SELECT *` in `db.xquery`'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: SelectAsterisk.html
+
+Isucon/Mysql2/WhereWithoutIndex:
+  Description: 'Check for `WHERE` without index'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: WhereWithoutIndex.html
+
+Isucon/Shell:
+  StyleGuideBaseURL: https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Shell/
+
+Isucon/Shell/Backtick:
+  Description: 'Avoid external command calls with backtick'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: Backtick.html
+
+Isucon/Shell/System:
+  Description: 'Avoid external command calls with `Kernel#system`'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: System.html
+
+Isucon/Sinatra:
+  StyleGuideBaseURL: https://sue445.github.io/rubocop-isucon/RuboCop/Cop/Isucon/Sinatra/
+
+Isucon/Sinatra/DisableLogging:
+  Description: 'Disable sinatra logging'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: DisableLogging.html
+
+Isucon/Sinatra/Logger:
+  Description: "Disable sinatra logger logging"
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: Logger.html
+
+Isucon/Sinatra/RackLogger:
+  Description: "Disable `request.env['rack.logger']` logging"
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: RackLogger.html
+
+Isucon/Sinatra/ServeStaticFile:
+  Description: 'Serve static files on front server (e.g. nginx) instead of sinatra app'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  StyleGuide: ServeStaticFile.html

data/config/enable-only-performance.yml

@@ -0,0 +1,30 @@
+require:
+  - rubocop-performance
+
+# Disable default cops (except Performance cops)
+Bundler:
+  Enabled: false
+
+Gemspec:
+  Enabled: false
+
+Layout:
+  Enabled: false
+
+Lint:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+Naming:
+  Enabled: false
+
+Performance:
+  Enabled: true
+
+Security:
+  Enabled: false
+
+Style:
+  Enabled: false

data/gemfiles/activerecord_6_1.gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 6.1.0"
+
+group :sqlite3 do
+  # c.f. https://github.com/rails/rails/blob/v6.1.0/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L13
+  gem "sqlite3", "~> 1.4"
+end
+
+# eval_gemfile "#{__dir__}/common.gemfile"
+
+gemspec path: "../"

data/gemfiles/activerecord_7_0.gemfile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 7.0.1"
+
+group :sqlite3 do
+  # c.f. https://github.com/rails/rails/blob/v7.0.1/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb#L13
+  gem "sqlite3", "~> 1.4"
+end
+
+# eval_gemfile "#{__dir__}/common.gemfile"
+
+gemspec path: "../"

data/lib/rubocop/cop/isucon/correctors/mysql2_n_plus_one_query_corrector/correctable_methods.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Correctors
+        class Mysql2NPlusOneQueryCorrector
+          # Check whether can correct
+          module CorrectableMethods
+            # @return [Boolean]
+            def correctable?
+              correctable_gda? && correctable_xquery_arg? &&
+                correctable_parent_receiver? && current_node.child_nodes.count == 3 &&
+                xquery_lvar.lvasgn_type? && %i[first last].include?(xquery_chained_method)
+            end
+
+            # @return [Boolean]
+            def correctable_gda?
+              gda&.select_query? && gda.table_names.count == 1 && !gda.limit_clause? &&
+                !gda.group_by_clause? && !gda.contains_aggregate_functions? && where_clause_with_only_single_unique_key?
+            end
+
+            # @return [Boolean]
+            def where_clause_with_only_single_unique_key?
+              where_clause_with_only_primary_key? || where_clause_with_only_single_unique_index_column?
+            end
+
+            # @return [Boolean]
+            def where_clause_with_only_primary_key?
+              return false unless gda.where_nodes.count == 1
+
+              primary_keys = connection.primary_keys(gda.table_names[0])
+              return false unless primary_keys.count == 1
+
+              primary_keys.first == where_column_without_quote
+            end
+
+            # @return [Boolean]
+            def where_clause_with_only_single_unique_index_column?
+              return false unless gda.where_nodes.count == 1
+
+              unique_index_columns = connection.unique_index_columns(gda.table_names[0])
+              unique_index_columns.any? { |columns| columns.count == 1 && columns.first == where_column_without_quote }
+            end
+
+            # @return [Boolean]
+            def correctable_xquery_arg? # rubocop:disable Metrics/AbcSize
+              return false if !xquery_arg&.send_type? || xquery_arg.node_parts.count != 3 || !xquery_arg.node_parts[0].lvar_type?
+
+              # Check one of hash[:key], hash["key"], hash.fetch(:key), hash.fetch("key")
+              return false unless %i[[] fetch].include?(xquery_arg.node_parts[1])
+              return false unless %i[sym str].include?(xquery_arg.node_parts[2].type)
+
+              true
+            end
+
+            # @return [Boolean]
+            def correctable_parent_receiver?
+              parent_receiver.lvar_type? || parent_receiver.send_type?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/correctors/mysql2_n_plus_one_query_corrector/replace_methods.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Correctors
+        class Mysql2NPlusOneQueryCorrector
+          # replace ast
+          module ReplaceMethods
+            def replace
+              replace_where_condition_in_sql
+              replace_xquery_2nd_arg
+              replace_chained_method_to_each_with_object
+              replace_to_2_lines
+            end
+
+            # Replace where condition in SQL (e.g. `id = ?` -> `id IN (?)`)
+            def replace_where_condition_in_sql
+              loc = offense_location(type: type, node: current_node, gda_location: where_condition_gda_loc)
+              return unless loc
+
+              corrector.replace(loc, "#{where_column} IN (?)")
+            end
+
+            # Replace 2nd arg in db.xquery (e.g. `course[:teacher_id]` -> `courses.map { |course| course[:teacher_id] }`)
+            def replace_xquery_2nd_arg
+              object_source = xquery_arg.node_parts[0].source
+              symbol_source = xquery_arg.node_parts[2].source
+
+              corrector.replace(
+                xquery_arg.loc.expression,
+                # e.g.
+                # courses.map { |course| course[:teacher_id] }
+                "#{parent_receiver.source}.map { |#{object_source}| #{object_source}[#{symbol_source}] }",
+              )
+            end
+
+            # Replace `.first` -> `.each_with_object({}) { |v, hash| hash[v[:id]] = v }`
+            def replace_chained_method_to_each_with_object
+              xquery_chained_method_begin_pos = current_node.loc.end.end_pos + 1
+              xquery_chained_method_range =
+                Parser::Source::Range.new(current_node.loc.expression.source_buffer,
+                                          xquery_chained_method_begin_pos,
+                                          xquery_chained_method_begin_pos + xquery_chained_method.length)
+
+              corrector.replace(xquery_chained_method_range, generate_each_with_object)
+            end
+
+            # @return [String]
+            #
+            # @example response example
+            #   each_with_object({}) { |v, hash| hash[v[:id]] = v }
+            def generate_each_with_object
+              hash_key =
+                case xquery_arg.node_parts[2].type
+                when :sym
+                  ":#{where_column_without_quote}"
+                when :str
+                  %("#{where_column_without_quote}")
+                end
+
+              "each_with_object({}) { |v, hash| hash[v[#{hash_key}]] = v }"
+            end
+
+            # rubocop:disable Layout/LineLength
+
+            # Split line
+            #
+            # @example Before
+            #   teacher = db.xquery("SELECT * FROM `users` WHERE `id` IN (?)", courses.map { |course| course[:teacher_id] }).each_with_object({}) { |v, hash| hash[v[:id]] = v }
+            #
+            # @example After
+            #   @users_by_id ||= db.xquery("SELECT * FROM `users` WHERE `id` IN (?)", ...).each_with_object({}) { |v, hash| hash[v[:id]] = v }
+            #   teacher = @users_by_id[course[:teacher_id]]
+            def replace_to_2_lines
+              # rubocop:enable Layout/LineLength
+
+              replace_to_2_lines_for_1st_line
+              replace_to_2_lines_for_2nd_line
+            end
+
+            def replace_to_2_lines_for_1st_line
+              range =
+                Parser::Source::Range.new(current_node.loc.expression.source_buffer,
+                                          xquery_lvar.loc.expression.begin_pos, current_node.loc.expression.begin_pos)
+
+              corrector.replace(range, "#{instance_var_name} ||= ")
+            end
+
+            # @return [String]
+            def instance_var_name
+              "@#{gda.table_names[0]}_by_#{where_column_without_quote}"
+            end
+
+            def replace_to_2_lines_for_2nd_line
+              indent_level = indent_level(current_node)
+
+              pos = xquery_lvar.loc.expression.end_pos + 1
+              range = Parser::Source::Range.new(current_node.loc.expression.source_buffer, pos, pos)
+
+              corrector.replace(range, "#{' ' * indent_level}#{generate_second_line}")
+            end
+
+            # @param node [RuboCop::AST::Node]
+            # @return [Integer]
+            def indent_level(node)
+              node.loc.expression.source_line =~ /^(\s+)/
+              return 0 unless Regexp.last_match(1)
+
+              Regexp.last_match(1).length
+            end
+
+            # @return [String]
+            #
+            # @example response example
+            #   teacher = @users_by_id[course[:teacher_id]]
+            def generate_second_line
+              object_source = xquery_arg.node_parts[0].source
+              symbol_source = xquery_arg.node_parts[2].source
+              "#{xquery_lvar.node_parts[0]} = #{instance_var_name}[#{object_source}[#{symbol_source}]]\n"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/correctors/mysql2_n_plus_one_query_corrector.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "mysql2_n_plus_one_query_corrector/correctable_methods"
+require_relative "mysql2_n_plus_one_query_corrector/replace_methods"
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Correctors
+        # rubocop:disable Layout/LineLength
+
+        # Corrector for {RuboCop::Cop::Isucon::Mysql2::NPlusOneQuery}
+        #
+        # @example Before
+        #   courses.map do |course|
+        #     teacher = db.xquery('SELECT * FROM `users` WHERE `id` = ?', course[:teacher_id]).first
+        #   end
+        #
+        # @example After
+        #   courses.map do |course|
+        #     @users_by_id ||= db.xquery('SELECT * FROM `users` WHERE `id` IN (?)', courses.map { |course| course[:teacher_id] }).each_with_object({}) { |v, hash| hash[v[:id]] = v }
+        #     teacher = @users_by_id[course[:teacher_id]]
+        #   end
+        class Mysql2NPlusOneQueryCorrector
+          # rubocop:enable Layout/LineLength
+
+          include Mixin::Mysql2XqueryMethods
+          include CorrectableMethods
+          include ReplaceMethods
+
+          # @return [RuboCop::Cop::Corrector]
+          attr_reader :corrector
+
+          # @return [RuboCop::AST::Node]
+          attr_reader :current_node
+
+          # @return [RuboCop::AST::Node]
+          attr_reader :parent_node
+
+          # @return [Symbol]
+          attr_reader :type
+
+          # @return [RuboCop::Isucon::GDA::Client]
+          attr_reader :gda
+
+          # @return [RuboCop::Isucon::DatabaseConnection]
+          attr_reader :connection
+
+          # @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 connection [RuboCop::Isucon::DatabaseConnection]
+          def initialize(corrector:, current_node:, parent_node:, type:, gda:, connection:) # rubocop:disable Metrics/ParameterLists
+            @corrector = corrector
+            @current_node = current_node
+            @parent_node = parent_node
+            @type = type
+            @gda = gda
+            @connection = connection
+          end
+
+          def correct
+            replace if correctable?
+          end
+
+          private
+
+          # @return [RuboCop::AST::Node,nil]
+          def parent_receiver
+            parent_node.child_nodes&.first&.receiver
+          end
+
+          # @return [RuboCop::Isucon::GDA::NodeLocation]
+          def where_condition_gda_loc
+            gda.where_nodes.first.location
+          end
+
+          # @return [String,nil]
+          def where_column
+            matched = where_condition_gda_loc&.body&.match(/([^\s]+)\s*=\s*\?/)
+
+            return nil unless matched
+
+            matched[1]
+          end
+
+          # @return [RuboCop::AST::Node]
+          def xquery_arg
+            current_node.child_nodes[2]
+          end
+
+          # @return [RuboCop::AST::Node]
+          def xquery_chained_method
+            current_node.parent.node_parts[1]
+          end
+
+          # @return [String]
+          def where_column_without_quote
+            where_column&.delete("`")
+          end
+
+          # @return [RuboCop::AST::Node,nil]
+          def xquery_lvar
+            current_node.parent&.parent
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mixin
+        # Database util methods for {RuboCop::Cop::Isucon::Mysql2}
+        module DatabaseMethods
+          # @return [RuboCop::Isucon::DatabaseConnection]
+          # @raise [RuboCop::Isucon::DatabaseConfigurationError] `Database` isn't configured in `.rubocop.yml`
+          def connection
+            return @connection if @connection
+
+            unless enabled_database?
+              raise RuboCop::Isucon::DatabaseConfigurationError, "`Database` isn't configured in `.rubocop.yml`"
+            end
+
+            @connection = RuboCop::Isucon::DatabaseConnection.new(cop_config["Database"])
+          end
+
+          # @return [Boolean]
+          def enabled_database?
+            adapter = cop_config.dig("Database", "adapter")
+            adapter && !adapter.empty?
+          end
+
+          # @param table_names [Array<String>]
+          # @param column_name [String]
+          # @return [String,nil]
+          def find_table_name_from_column_name(table_names:, column_name:)
+            table_names.each do |table_name|
+              column_names = connection.column_names(table_name)
+              return table_name if column_names.include?(column_name)
+            end
+            nil
+          end
+
+          private
+
+          # @param node [RuboCop::AST::Node]
+          def with_error_handling(node)
+            yield
+          rescue ActiveRecord::StatementInvalid => e
+            # NOTE: suppress error (e.g. table isn't found in database)
+            print_warning(node: node, error: e)
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @param error [StandardError]
+          def print_warning(node:, error:)
+            file_path = processed_source.file_path
+            line_num = node.loc.expression.line
+            warn "Warning: #{error.message} (#{file_path}:#{line_num})"
+          end
+        end
+      end
+    end
+  end
+end