rubocop-isucon 0.1.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Isucon
+      module Sinatra
+        # Serve static files on front server (e.g. nginx) instead of sinatra app
+        #
+        # @example
+        #   # bad
+        #   class App < Sinatra::Base
+        #     get '/' do
+        #       content_type :html
+        #       File.read(File.join(__dir__, '..', 'public', 'index.html'))
+        #     end
+        #   end
+        #
+        #   # good (e.g. Serve on nginx)
+        #   location / {
+        #     try_files $uri $uri/ /index.html;
+        #   }
+        #
+        class ServeStaticFile < Base
+          include Mixin::SinatraMethods
+
+          MSG = "Serve static files on front server (e.g. nginx) instead of sinatra app"
+
+          # @!method file_read_method?(node)
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :file_read_method?, <<~PATTERN
+            (send (const nil? :File) :read ...)
+          PATTERN
+
+          # @!method get_block?(node)
+          #   @param node [RuboCop::AST::Node]
+          #   @return [Boolean]
+          def_node_matcher :get_block?, <<~PATTERN
+            (block (send nil? :get ...) ...)
+          PATTERN
+
+          # @param node [RuboCop::AST::Node]
+          def on_send(node)
+            return unless parent_is_sinatra_app?(node)
+            return unless file_read_method?(node)
+
+            parent = parent_get_node(node)
+            return unless parent
+
+            return unless end_of_block?(node: node, parent: parent)
+
+            add_offense(parent)
+          end
+
+          private
+
+          # @param node [RuboCop::AST::Node]
+          # @return [RuboCop::AST::Node]
+          def parent_get_node(node)
+            node.each_ancestor.find { |ancestor| get_block?(ancestor) }
+          end
+
+          # @param node [RuboCop::AST::Node]
+          # @param parent [RuboCop::AST::Node]
+          # @return [Boolean]
+          def end_of_block?(node:, parent:)
+            parent.child_nodes.last&.child_nodes&.last == node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/isucon_cops.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "isucon/mixin/database_methods"
+require_relative "isucon/mixin/mysql2_xquery_methods"
+require_relative "isucon/mixin/sinatra_methods"
+
+require_relative "isucon/correctors/mysql2_n_plus_one_query_corrector"
+
+require_relative "isucon/mysql2/join_without_index"
+require_relative "isucon/mysql2/many_join_table"
+require_relative "isucon/mysql2/n_plus_one_query"
+require_relative "isucon/mysql2/prepare_execute"
+require_relative "isucon/mysql2/select_asterisk"
+require_relative "isucon/mysql2/where_without_index"
+require_relative "isucon/sinatra/disable_logging"
+require_relative "isucon/sinatra/logger"
+require_relative "isucon/sinatra/rack_logger"
+require_relative "isucon/sinatra/serve_static_file"
+require_relative "isucon/shell/backtick"
+require_relative "isucon/shell/system"

data/lib/rubocop/isucon/database_connection.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    # Manage database connection
+    class DatabaseConnection
+      # @param database_config [Hash] Same as `ActiveRecord::Base.establish_connection` argument
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionHandling.html#method-i-establish_connection
+      def initialize(database_config)
+        ActiveRecord::Base.establish_connection(database_config)
+        @column_names_by_table = {}
+        @indexes_by_table = {}
+        @primary_keys_by_table = {}
+      end
+
+      # @param table_name [String]
+      # @return [Array<String>]
+      def column_names(table_name)
+        @column_names_by_table[table_name] ||= ActiveRecord::Base.connection.columns(table_name).map(&:name)
+      end
+
+      # @param table_name [String]
+      # @return [Array<ActiveRecord::ConnectionAdapters::IndexDefinition>]
+      # @see https://github.com/rails/rails/blob/v6.1.4.1/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb#L8
+      def indexes(table_name)
+        @indexes_by_table[table_name] ||= ActiveRecord::Base.connection.indexes(table_name)
+      end
+
+      # @param table_name [String]
+      # @return [Array<Array<String>>] column names of indexes
+      def unique_index_columns(table_name)
+        indexes(table_name).select(&:unique).map(&:columns)
+      end
+
+      # @param table_name [String]
+      # @return [Array<String>] primary key's column names
+      def primary_keys(table_name)
+        @primary_keys_by_table[table_name] ||= ActiveRecord::Base.connection.primary_keys(table_name)
+      end
+    end
+  end
+end

data/lib/rubocop/isucon/gda/client.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    module GDA
+      # Client for `GDA`
+      class Client # rubocop:disable Metrics/ClassLength
+        # @return [GDA::Nodes::Select]
+        attr_reader :ast
+
+        # @return [String]
+        attr_reader :sql
+
+        # @param sql [String,nil]
+        # @param ast [GDA::Nodes::Select]
+        # @note if `sql` is `nil`, `ast` is required
+        def initialize(sql, ast: nil)
+          @sql = sql
+
+          if ast
+            # called from subquery AST
+            @ast = ast
+          else
+            # called from root AST
+            @ast = statement.ast
+            RuboCop::Isucon::GDA::NodePatcher.new(sql).accept(@ast)
+          end
+        end
+
+        # @return [Array<String>]
+        def table_names
+          return @table_names if @table_names
+
+          @table_names =
+            if from_targets?
+              ast.from.targets.map(&:table_name).compact.uniq
+            else
+              []
+            end
+        end
+
+        # @return [Array<RuboCop::Isucon::GDA::WhereCondition>]
+        def where_conditions
+          where_nodes.
+            map do |node|
+              where_operands = node.operands.map do |operand|
+                create_where_operand(operand)
+              end
+
+              WhereCondition.new(
+                operator: node.operator,
+                operands: where_operands,
+              )
+            end
+        end
+
+        # @return [Array<RuboCop::Isucon::GDA::JoinCondition>]
+        def join_conditions
+          return [] unless from_joins?
+
+          ast.from.joins.map do |node|
+            join_operands = node.expr.cond.operands.map do |operand|
+              create_join_operand(operand)
+            end
+
+            JoinCondition.new(
+              operator: node.expr.cond.operator,
+              operands: join_operands,
+            )
+          end
+        end
+
+        # @return [Array<GDA::Nodes::Operation>]
+        def where_nodes
+          return [] unless ast.respond_to?(:where_cond)
+
+          ast.where_cond.to_a.
+            select { |node| node.instance_of?(::GDA::Nodes::Operation) && node.operator }
+        end
+
+        # @return [Hash,nil]
+        def serialize_statement
+          return nil unless @sql
+
+          JSON.parse(statement.serialize)
+        end
+
+        # @yieldparam gda [RuboCop::Isucon::GDA::Client]
+        def visit_subquery_recursive(&block)
+          return unless from_targets?
+
+          ast.from.targets.each do |target|
+            next unless target.expr.select
+
+            gda = Client.new(nil, ast: target.expr.select)
+            yield(gda)
+            gda.visit_subquery_recursive(&block)
+          end
+        end
+
+        # @yieldparam gda [RuboCop::Isucon::GDA::Client]
+        def visit_all(&block)
+          yield(self)
+          visit_subquery_recursive(&block)
+        end
+
+        # @return [Boolean]
+        def select_query?
+          ast.is_a?(::GDA::Nodes::Select)
+        end
+
+        # Whether `SELECT` clause contains aggregate functions (`COUNT`, `MAX`, `MIN`, `SUM` or `AVG`)
+        # @return [Boolean]
+        def contains_aggregate_functions?
+          aggregate_function_names = %w[COUNT MAX MIN SUM AVG]
+          ast.expr_list.any? do |select_field_node|
+            aggregate_function_names.include?(select_field_node.expr.func&.function_name&.upcase)
+          end
+        end
+
+        # Whether AST has `GROUP BY` clause
+        # @return [Boolean]
+        def group_by_clause?
+          !ast.group_by.empty?
+        end
+
+        # Whether AST has `LIMIT` clause
+        # @return [Boolean]
+        def limit_clause?
+          !!ast.limit_count
+        end
+
+        # @return [Boolean]
+        def from_joins?
+          ast.respond_to?(:from) && ast.from.respond_to?(:joins)
+        end
+
+        # @return [Boolean]
+        def from_targets?
+          ast.respond_to?(:from) && ast.from.respond_to?(:targets)
+        end
+
+        private
+
+        # @return [GDA::SQL::Statement]
+        # @raise [ArgumentError] called from subquery
+        def statement
+          return @statement if @statement
+
+          raise ArgumentError, "@sql is required" unless @sql
+
+          @statement = ::GDA::SQL::Parser.new.parse(RuboCop::Isucon::GDA.normalize_sql(@sql))
+        end
+
+        # @param operand [GDA::Nodes::Expr]
+        # @return [RuboCop::Isucon::GDA::WhereOperand]
+        def create_where_operand(operand)
+          WhereOperand.new(value: operand.value.gsub(/^.+\./, ""), node: operand)
+        end
+
+        # @param operand [GDA::Nodes::Expr]
+        # @return [RuboCop::Isucon::GDA::JoinOperand]
+        def create_join_operand(operand)
+          table_name_or_as, column_name = operand.value.split(".", 2)
+
+          if (target = from_targets.find { |t| table_name_or_as == t[:table_name] })
+            return JoinOperand.new(table_name: target[:table_name], column_name: column_name, as: nil, node: operand)
+          end
+
+          if (target = from_targets.find { |t| table_name_or_as == t[:as] })
+            return JoinOperand.new(table_name: target[:table_name], column_name: column_name, as: target[:as], node: operand)
+          end
+
+          JoinOperand.new(table_name: nil, column_name: column_name, as: nil, node: operand)
+        end
+
+        # @return [Hash]
+        def from_targets
+          @from_targets ||= ast.from.targets.map { |target| { table_name: target.table_name, as: target.as } }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/isucon/gda/gda_ext.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+GDA::Nodes::Node.class_eval do
+  # @!attribute [rw] location
+  #   @return [RuboCop::Isucon::GDA::NodeLocation]
+  attr_accessor :location
+
+  # @return [String]
+  def inspect
+    # NOTE: Suppress the inclusion of instance variables in `#inspect`
+    encoded_object_id = super[/#<#{self.class.name}:0x([0-9a-z]{16})/, 1]
+    "#<#{self.class.name}:0x#{encoded_object_id}>"
+  end
+end
+
+GDA::Nodes::Select.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :distinct_expr
+  memorize :expr_list
+  memorize :from
+  memorize :where_cond
+  memorize :group_by
+  memorize :having_cond
+  memorize :order_by
+  memorize :limit_count
+  memorize :limit_offset
+end
+
+GDA::Nodes::Insert.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :table
+  memorize :fields_list
+  memorize :values_list
+  memorize :select
+end
+
+GDA::Nodes::Update.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :table
+  memorize :fields_list
+  memorize :expr_list
+  memorize :cond
+end
+
+GDA::Nodes::Join.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :expr
+  memorize :use
+end
+
+GDA::Nodes::Delete.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :table
+  memorize :cond
+end
+
+GDA::Nodes::SelectField.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :expr
+end
+
+GDA::Nodes::Expr.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :func
+  memorize :cond
+  memorize :select
+  memorize :case_s
+  memorize :param_spec
+end
+
+GDA::Nodes::From.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :targets
+  memorize :joins
+end
+
+GDA::Nodes::Target.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :expr
+end
+
+GDA::Nodes::Operation.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :operands
+end
+
+GDA::Nodes::Function.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :args_list
+end
+
+GDA::Nodes::Order.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :expr
+end
+
+GDA::Nodes::Unknown.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :expressions
+end
+
+GDA::Nodes::Compound.class_eval do
+  extend RuboCop::Isucon::MemorizeMethods
+
+  memorize :stmt_list
+end

data/lib/rubocop/isucon/gda/join_condition.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    module GDA
+      # response of {RuboCop::Isucon::GDA::Client#join_conditions}
+      class JoinCondition
+        # @!attribute [rw] operator
+        #   @return [String]
+        attr_accessor :operator
+
+        # @!attribute [rw] operands
+        #   @return [Array<RuboCop::Isucon::GDA::JoinOperand>]
+        attr_accessor :operands
+
+        # @param operator [String]
+        # @param operands [Array<RuboCop::Isucon::GDA::JoinOperand>]
+        def initialize(operator: nil, operands: [])
+          @operator = operator
+          @operands = operands
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/isucon/gda/join_operand.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    module GDA
+      # response of {RuboCop::Isucon::GDA::Client#join_conditions}
+      class JoinOperand
+        # @!attribute [rw] table_name
+        #   @return [String]
+        attr_accessor :table_name
+
+        # @!attribute [rw] column_name
+        #   @return [String]
+        attr_accessor :column_name
+
+        # @!attribute [rw] as
+        #   @return [String]
+        attr_accessor :as
+
+        # @!attribute [rw] node
+        #   @return [GDA::Nodes::Expr]
+        attr_accessor :node
+
+        # @param table_name [String]
+        # @param column_name [String]
+        # @param as [String]
+        # @param node [GDA::Nodes::Expr]
+        def initialize(table_name: nil, column_name: nil, as: nil, node: nil) # rubocop:disable Naming/MethodParameterName
+          @table_name = table_name
+          @column_name = column_name
+          @as = as
+          @node = node
+        end
+
+        # @param other [RuboCop::Isucon::GDA::JoinOperand]
+        # @return [Boolean]
+        def ==(other)
+          other.is_a?(JoinOperand) &&
+            table_name == other.table_name &&
+            column_name == other.column_name &&
+            as == other.as
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/isucon/gda/node_location.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    module GDA
+      # Location in SQL
+      class NodeLocation
+        # @return [Integer]
+        attr_reader :begin_pos
+
+        # @return [Integer]
+        attr_reader :end_pos
+
+        # @return [String]
+        attr_reader :body
+
+        # @param begin_pos [Integer]
+        # @param end_pos [Integer]
+        # @param body [String]
+        def initialize(begin_pos:, end_pos:, body:)
+          @begin_pos = begin_pos
+          @end_pos = end_pos
+          @body = body
+        end
+
+        # @param other [RuboCop::Isucon::GDA::NodeLocation]
+        # @return [Boolean]
+        def ==(other)
+          other.is_a?(NodeLocation) &&
+            begin_pos == other.begin_pos &&
+            end_pos == other.end_pos &&
+            body == other.body
+        end
+
+        # @return [Integer]
+        def length
+          end_pos - begin_pos
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/isucon/gda/node_patcher.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Isucon
+    module GDA
+      # Monkey patching to `GDA::Nodes::Node`
+      class NodePatcher < ::GDA::Visitors::Visitor
+        # @param sql [String]
+        def initialize(sql)
+          @sql = sql
+          @normalized_sql = RuboCop::Isucon::GDA.normalize_sql(sql)
+          @current_operation_pos = 0
+          @current_expr_pos = 0
+          super()
+        end
+
+        private
+
+        # @param node [GDA::Nodes::Operation]
+        def visit_GDA_Nodes_Operation(node) # rubocop:disable Naming/MethodName -- This method is called from `GDA::Visitors::Visitor#visit` c.f. https://github.com/tenderlove/gda/blob/v1.1.0/lib/gda/visitors/visitor.rb#L13-L17
+          return super unless node.operator
+
+          pattern = operand_pattern(node)
+          return super unless pattern
+
+          node.location = search_operation_location(pattern)
+
+          super
+        end
+
+        # @param node [GDA::Nodes::Operation]
+        # @return [Regexp,nil]
+        def operand_pattern(node)
+          operand0 = Regexp.escape(node.operands[0].value)
+          operator = Regexp.escape(node.operator)
+
+          case node.operands.count
+          when 1
+            /#{operand0}\s*#{operator}/
+          when 2
+            /#{operand0}\s*#{operator}\s*#{Regexp.escape(node.operands[1].value)}/
+          end
+        end
+
+        # @param pattern [Regexp]
+        # @return [RuboCop::Isucon::GDA::NodeLocation,nil]
+        def search_operation_location(pattern)
+          result = search_location(pattern, @current_operation_pos)
+          return nil unless result
+
+          @current_operation_pos = result[:current_pos] if result[:current_pos]
+          result[:location]
+        end
+
+        # @param pattern [Regexp]
+        # @param current_pos [Integer]
+        # @return [Hash]
+        def search_location(pattern, current_pos)
+          begin_pos = @normalized_sql.index(pattern, current_pos)
+
+          return nil unless Regexp.last_match
+
+          length = Regexp.last_match[0].length
+          end_pos = begin_pos + length
+
+          begin_pos -= 1 if @sql[begin_pos - 1] == "`"
+          end_pos += 1 if @sql[end_pos] == "`"
+
+          {
+            location: NodeLocation.new(begin_pos: begin_pos, end_pos: end_pos, body: @sql[begin_pos...end_pos]),
+            current_pos: end_pos,
+          }
+        end
+
+        # @param node [GDA::Nodes::Expr]
+        def visit_GDA_Nodes_Expr(node) # rubocop:disable Naming/MethodName -- This method is called from `GDA::Visitors::Visitor#visit` c.f. https://github.com/tenderlove/gda/blob/v1.1.0/lib/gda/visitors/visitor.rb#L13-L17
+          return super unless node.value
+
+          escaped_value = Regexp.escape(node.value).gsub("\\.", "\\s*\\.\\s*")
+          node.location = search_expr_location(/(?<=[\s,])#{escaped_value}(?=[\s,])/)
+
+          begin
+            super
+          rescue RuntimeError => e
+            raise unless e.message.strip == "unknown node type: 505"
+          end
+        end
+
+        # @param pattern [Regexp]
+        # @return [RuboCop::Isucon::GDA::NodeLocation,nil]
+        def search_expr_location(pattern)
+          result = search_location(pattern, @current_expr_pos)
+          return nil unless result
+
+          @current_expr_pos = result[:current_pos] if result[:current_pos]
+          result[:location]
+        end
+      end
+    end
+  end
+end