rubocop-isucon 0.1.0

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # Use `db.xquery` instead of `db.prepare.execute`
+        #
+        # @example
+        #   # bad (auto-correct isn't possible)
+        #   statement = db.prepare('SELECT * FROM `users` WHERE `id` = ?')
+        #   statement.execute(
+        #     session[:user][:id]
+        #   ).first
+        #
+        #   # bad (auto-correct is possible)
+        #   db.prepare('SELECT * FROM `users` WHERE `id` = ?').execute(
+        #     session[:user][:id]
+        #   ).first
+        #
+        #   # good
+        #   require 'mysql2-cs-bind'
+        #
+        #   db.xquery('SELECT * FROM `users` WHERE `id` = ?',
+        #     session[:user][:id]
+        #   ).first
+        #
+        class PrepareExecute < Base
+          extend AutoCorrector
+
+          MSG = "Use `db.xquery` instead of `db.prepare.execute`"
+
+          EXECUTE_LENGTH = "execute".length
+
+          # @!method find_prepare_execute(node)
+          def_node_search :find_prepare_execute, <<~PATTERN
+            (send
+              (send
+                (send nil? _) :prepare $_
+              )
+              :execute
+              ...
+            )
+          PATTERN
+
+          # @!method prepare_with_execute?(node)
+          # @return [Boolean]
+          def_node_matcher :prepare_with_execute?, <<~PATTERN
+            (send
+              (send
+                (send nil? _) :prepare _
+              )
+              :execute
+              ...
+            )
+          PATTERN
+
+          # @!method prepare?(node)
+          # @return [Boolean]
+          def_node_matcher :prepare?, <<~PATTERN
+            (send
+              (send nil? _) :prepare _
+            )
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            if prepare_with_execute?(node)
+              find_prepare_execute(node) do |prepare_arg_node|
+                add_offense(node) do |corrector|
+                  perform_autocorrect(corrector: corrector, node: node, prepare_arg_node: prepare_arg_node)
+                end
+              end
+              return
+            end
+
+            add_offense(node) if prepare_without_execute?(node)
+          end
+
+          private
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          # @param prepare_arg_node [RuboCop::AST::Node]
+          def perform_autocorrect(corrector:, node:, prepare_arg_node:)
+            if node.child_nodes[1]
+              perform_autocorrect_for_any_args(corrector: corrector, node: node, prepare_arg_node: prepare_arg_node)
+            else
+              perform_autocorrect_for_no_args(corrector: corrector, node: node, prepare_arg_node: prepare_arg_node)
+            end
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          # @param prepare_arg_node [RuboCop::AST::Node]
+          def perform_autocorrect_for_any_args(corrector:, node:, prepare_arg_node:)
+            loc = offence_location(node: node, suffix_length: EXECUTE_LENGTH + 1)
+            corrector.replace(loc, "xquery(#{prepare_arg_node.source},")
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          # @param prepare_arg_node [RuboCop::AST::Node]
+          def perform_autocorrect_for_no_args(corrector:, node:, prepare_arg_node:)
+            suffix_length =
+              if node.source.end_with?("execute()")
+                EXECUTE_LENGTH + 2
+              else
+                EXECUTE_LENGTH
+              end
+            loc = offence_location(node: node, suffix_length: suffix_length)
+            corrector.replace(loc, "xquery(#{prepare_arg_node.source})")
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @param suffix_length [Integer]
+          # @return [Parser::Source::Rang]
+          def offence_location(node:, suffix_length:)
+            prepare_begin_pos = node.child_nodes[0].loc.selector.begin_pos
+            execute_begin_pos = node.child_nodes[0].loc.end.end_pos + 1
+            execute_end_pos = execute_begin_pos + suffix_length
+
+            Parser::Source::Range.new(node.loc.expression.source_buffer, prepare_begin_pos, execute_end_pos)
+          end
+
+          # Whether `prepare` isn't followed by `execute`
+          # @param node [RuboCop::AST::Node]
+          # @return [Boolean]
+          def prepare_without_execute?(node)
+            prepare?(node) && !prepare_with_execute?(node.parent)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # Avoid `SELECT *` in `db.xquery`
+        #
+        # @note If `Database` isn't configured, auto-correct will not be available. (Only offense detection can be used)
+        #
+        # @note This cop replaces `SELECT *` with a `SELECT` by the columns present in the table (e.g. `SELECT id, name`),
+        #       but does not check whether the columns are actually used.
+        #       Please manually delete unused columns after auto corrected
+        #
+        # @example
+        #   # bad
+        #   db.xquery('SELECT * FROM users')
+        #
+        #   # bad
+        #   db.xquery('SELECT users.* FROM users')
+        #
+        #   # good
+        #   db.xquery('SELECT id, name FROM users')
+        #
+        #   # good
+        #   db.xquery('SELECT users.id, users.name FROM users')
+        #
+        class SelectAsterisk < Base
+          include Mixin::DatabaseMethods
+          include Mixin::Mysql2XqueryMethods
+
+          extend AutoCorrector
+
+          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_xquery(node) do |type, root_gda|
+                next unless 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:)
+            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/mysql2/where_without_index.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Mysql2
+        # Check for `WHERE` without index
+        #
+        # @note If `Database` isn't configured, this cop's feature (offense detection and auto-correct) will not be available.
+        #
+        # @example
+        #   # bad (user_id is not indexed)
+        #   db.xquery('SELECT id, title FROM articles WHERE used_id = ?', user_id)
+        #
+        #   # good (user_id is indexed)
+        #   db.xquery('SELECT id, title FROM articles WHERE used_id = ?', user_id)
+        #
+        #   # good (id is primary key)
+        #   db.xquery('SELECT id, title FROM articles WHERE id = ?', id)
+        #
+        class WhereWithoutIndex < Base
+          include Mixin::DatabaseMethods
+          include Mixin::Mysql2XqueryMethods
+
+          MSG = "This where 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|
+                next unless root_gda
+                next if exists_index_in_where_clause_columns?(root_gda)
+
+                register_offense(type: type, node: node, root_gda: root_gda)
+              end
+            end
+          end
+
+          private
+
+          # @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)
+            format(MSG, 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/shell/backtick.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Shell
+        # Avoid external command calls with backtick
+        #
+        # @example
+        #   # bad
+        #   def digest(src)
+        #     `printf "%s" #{Shellwords.shellescape(src)} | openssl dgst -sha512 | sed 's/^.*= //'`.strip
+        #   end
+        #
+        #   # bad
+        #   def digest(src)
+        #     %x(printf "%s" \#{Shellwords.shellescape(src)} | openssl dgst -sha512 | sed 's/^.*= //').strip
+        #   end
+        #
+        #   # good
+        #   def digest(src)
+        #     OpenSSL::Digest::SHA512.hexdigest(src)
+        #   end
+        #
+        class Backtick < Base
+          MSG = "Use pure-ruby code instead of external command execution if possible"
+
+          # @param node [RuboCop::AST::Node]
+          def on_xstr(node)
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/shell/system.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Shell
+        # Avoid external command calls with `Kernel#system`
+        #
+        # @example
+        #   # bad
+        #   system("sleep 1")
+        #
+        #   # good
+        #   sleep 1
+        #
+        class System < Base
+          MSG = "Use pure-ruby code instead of external command execution if possible"
+
+          # Whether matches `system`
+          # @!method system?(node)
+          # @return [Boolean]
+          def_node_matcher :system?, <<~PATTERN
+            (send nil? :system ...)
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            return unless system?(node)
+
+            add_offense(node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sinatra/disable_logging.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sinatra
+        # Disable sinatra logging
+        #
+        # @example
+        #   # bad
+        #   class App < Sinatra::Base
+        #     enable :logging
+        #   end
+        #
+        #   # bad
+        #   class App < Sinatra::Base
+        #   end
+        #
+        #   # good
+        #   class App < Sinatra::Base
+        #     disable :logging
+        #   end
+        #
+        class DisableLogging < Base
+          include Mixin::SinatraMethods
+
+          extend AutoCorrector
+
+          MSG = "Disable sinatra logging."
+
+          # @!method logging_enabled?(node)
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :logging_enabled?, <<~PATTERN
+            (send nil? :enable (sym :logging))
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            return unless parent_is_sinatra_app?(node)
+            return unless logging_enabled?(node)
+
+            add_offense(node) do |corrector|
+              perform_autocorrect_for_on_send(corrector: corrector, node: node)
+            end
+          end
+
+          # @param node [RuboCop::AST::Node]
+          def on_class(node)
+            return unless subclass_of_sinatra_base?(node)
+            return if subclass_of_sinatra_base_contains_logging?(node)
+
+            add_offense(node) do |corrector|
+              perform_autocorrect_for_on_class(corrector: corrector, node: node)
+            end
+          end
+
+          private
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          def perform_autocorrect_for_on_send(corrector:, node:)
+            corrector.replace(node, "disable :logging")
+          end
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          def perform_autocorrect_for_on_class(corrector:, node:)
+            sinatra_base_node = node.child_nodes[1]
+
+            content = [
+              "\n",
+              (" " * (node.loc.column + 2)),
+              "disable :logging",
+            ].join
+
+            corrector.insert_after(sinatra_base_node.loc.expression, content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sinatra/logger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sinatra
+        # Disable sinatra logger logging
+        #
+        # @example
+        #   # bad
+        #   logger.error "Search condition not found"
+        #
+        #   # good
+        #   # no logging
+        #
+        class Logger < Base
+          MSG = "Don't use `logger`"
+
+          extend AutoCorrector
+
+          # @!method logger?(node)
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :logger?, <<~PATTERN
+            (send
+              (send nil? :logger)
+              {:debug | :error | :fatal | :info | :warn}
+              ...
+            )
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            return unless logger?(node)
+
+            add_offense(node) do |corrector|
+              perform_autocorrect(corrector: corrector, node: node)
+            end
+          end
+
+          private
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          def perform_autocorrect(corrector:, node:)
+            corrector.replace(node, "")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon/sinatra/rack_logger.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sinatra
+        # Disable `request.env['rack.logger']` logging
+        #
+        # @example
+        #   # bad
+        #   request.env['rack.logger'].warn 'drop post isu condition request'
+        #
+        #   # good
+        #   # no logging
+        class RackLogger < Base
+          MSG = "Don't use `request.env['rack.logger']`"
+
+          extend AutoCorrector
+
+          # @!method rack_logger?(node)
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :rack_logger?, <<~PATTERN
+            (send
+              (send
+                (send
+                  (send nil? :request)
+                  :env
+                )
+                :[]
+                (str "rack.logger")
+              )
+              {:debug | :error | :fatal | :info | :warn}
+              ...
+            )
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            return unless rack_logger?(node)
+
+            add_offense(node) do |corrector|
+              perform_autocorrect(corrector: corrector, node: node)
+            end
+          end
+
+          private
+
+          # @param corrector [RuboCop::Cop::Corrector]
+          # @param node [RuboCop::AST::Node]
+          def perform_autocorrect(corrector:, node:)
+            corrector.replace(node, "")
+          end
+        end
+      end
+    end
+  end
+end