rubocop-rails 2.0.1 → 2.19.1

data/lib/rubocop/cop/rails/where_equals.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies places where manually constructed SQL
+      # in `where` can be replaced with `where(attribute: value)`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because is may change SQL.
+      #   See: https://github.com/rubocop/rubocop-rails/issues/403
+      #
+      # @example
+      #   # bad
+      #   User.where('name = ?', 'Gabe')
+      #   User.where('name = :name', name: 'Gabe')
+      #   User.where('name IS NULL')
+      #   User.where('name IN (?)', ['john', 'jane'])
+      #   User.where('name IN (:names)', names: ['john', 'jane'])
+      #   User.where('users.name = :name', name: 'Gabe')
+      #
+      #   # good
+      #   User.where(name: 'Gabe')
+      #   User.where(name: nil)
+      #   User.where(name: ['john', 'jane'])
+      #   User.where(users: { name: 'Gabe' })
+      class WhereEquals < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing SQL.'
+        RESTRICT_ON_SEND = %i[where].freeze
+
+        def_node_matcher :where_method_call?, <<~PATTERN
+          {
+            (send _ :where (array $str_type? $_ ?))
+            (send _ :where $str_type? $_ ?)
+          }
+        PATTERN
+
+        def on_send(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            range = offense_range(node)
+
+            column_and_value = extract_column_and_value(template_node, value_node)
+            return unless column_and_value
+
+            good_method = build_good_method(*column_and_value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
+          end
+        end
+
+        EQ_ANONYMOUS_RE = /\A([\w.]+)\s+=\s+\?\z/.freeze             # column = ?
+        IN_ANONYMOUS_RE = /\A([\w.]+)\s+IN\s+\(\?\)\z/i.freeze       # column IN (?)
+        EQ_NAMED_RE     = /\A([\w.]+)\s+=\s+:(\w+)\z/.freeze         # column = :column
+        IN_NAMED_RE     = /\A([\w.]+)\s+IN\s+\(:(\w+)\)\z/i.freeze   # column IN (:column)
+        IS_NULL_RE      = /\A([\w.]+)\s+IS\s+NULL\z/i.freeze         # column IS NULL
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def extract_column_and_value(template_node, value_node)
+          value =
+            case template_node.value
+            when EQ_ANONYMOUS_RE, IN_ANONYMOUS_RE
+              value_node.source
+            when EQ_NAMED_RE, IN_NAMED_RE
+              return unless value_node&.hash_type?
+
+              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
+              pair.value.source
+            when IS_NULL_RE
+              'nil'
+            else
+              return
+            end
+
+          [Regexp.last_match(1), value]
+        end
+
+        def build_good_method(column, value)
+          if column.include?('.')
+            table, column = column.split('.')
+
+            "where(#{table}: { #{column}: #{value} })"
+          else
+            "where(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/where_exists.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces consistent style when using `exists?`.
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'exists'
+      # then the cop enforces `exists?(...)` over `where(...).exists?`.
+      #
+      # When EnforcedStyle is 'where' then the cop enforces
+      # `where(...).exists?` over `exists?(...)`.
+      #
+      # @safety
+      #   This cop is unsafe for autocorrection because the behavior may change on the following case:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Author.includes(:articles).where(articles: {id: id}).exists?
+      #   #=> Perform `eager_load` behavior (`LEFT JOIN` query) and get result.
+      #
+      #   Author.includes(:articles).exists?(articles: {id: id})
+      #   #=> Perform `preload` behavior and `ActiveRecord::StatementInvalid` error occurs.
+      #   ----
+      #
+      # @example EnforcedStyle: exists (default)
+      #   # bad
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #
+      #   # good
+      #   User.exists?(name: 'john')
+      #   User.where('length(name) > 10').exists?
+      #   user.posts.exists?(published: true)
+      #
+      # @example EnforcedStyle: where
+      #   # bad
+      #   User.exists?(name: 'john')
+      #   User.exists?(['name = ?', 'john'])
+      #   User.exists?('name = ?', 'john')
+      #   user.posts.exists?(published: true)
+      #
+      #   # good
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #   User.where('length(name) > 10').exists?
+      class WhereExists < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[exists?].freeze
+
+        def_node_matcher :where_exists_call?, <<~PATTERN
+          (send (send _ :where $...) :exists?)
+        PATTERN
+
+        def_node_matcher :exists_with_args?, <<~PATTERN
+          (send _ :exists? $...)
+        PATTERN
+
+        def on_send(node)
+          find_offenses(node) do |args|
+            return unless convertable_args?(args)
+
+            range = correction_range(node)
+            good_method = build_good_method(args)
+            message = format(MSG, good_method: good_method, bad_method: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
+          end
+        end
+
+        private
+
+        def where_style?
+          style == :where
+        end
+
+        def exists_style?
+          style == :exists
+        end
+
+        def find_offenses(node, &block)
+          if exists_style?
+            where_exists_call?(node, &block)
+          elsif where_style?
+            exists_with_args?(node, &block)
+          end
+        end
+
+        def convertable_args?(args)
+          return false if args.empty?
+
+          args.size > 1 || args[0].hash_type? || args[0].array_type?
+        end
+
+        def correction_range(node)
+          if exists_style?
+            node.receiver.loc.selector.join(node.loc.selector)
+          elsif where_style?
+            node.loc.selector.with(end_pos: node.source_range.end_pos)
+          end
+        end
+
+        def build_good_method(args)
+          if exists_style?
+            build_good_method_exists(args)
+          elsif where_style?
+            build_good_method_where(args)
+          end
+        end
+
+        def build_good_method_exists(args)
+          if args.size > 1
+            "exists?([#{args.map(&:source).join(', ')}])"
+          else
+            "exists?(#{args[0].source})"
+          end
+        end
+
+        def build_good_method_where(args)
+          if args.size > 1
+            "where(#{args.map(&:source).join(', ')}).exists?"
+          else
+            "where(#{args[0].source}).exists?"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/where_missing.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use `where.missing(...)` to find missing relationship records.
+      #
+      # This cop is enabled in Rails 6.1 or higher.
+      #
+      # @example
+      #   # bad
+      #   Post.left_joins(:author).where(authors: { id: nil })
+      #
+      #   # good
+      #   Post.where.missing(:author)
+      #
+      class WhereMissing < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `where.missing(:%<left_joins_association>s)` instead of ' \
+              '`%<left_joins_method>s(:%<left_joins_association>s).where(%<where_association>s: { id: nil })`.'
+        RESTRICT_ON_SEND = %i[left_joins left_outer_joins].freeze
+
+        minimum_target_rails_version 6.1
+
+        # @!method where_node_and_argument(node)
+        def_node_search :where_node_and_argument, <<~PATTERN
+          $(send ... :where (hash <(pair $(sym _) (hash (pair (sym :id) (nil))))...> ))
+        PATTERN
+
+        # @!method missing_relationship(node)
+        def_node_search :missing_relationship, <<~PATTERN
+          (pair (sym _) (hash (pair (sym :id) (nil))))
+        PATTERN
+
+        def on_send(node)
+          return unless node.first_argument.sym_type?
+
+          root_receiver = root_receiver(node)
+          where_node_and_argument(root_receiver) do |where_node, where_argument|
+            next unless root_receiver == root_receiver(where_node)
+            next unless same_relationship?(where_argument, node.first_argument)
+
+            range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+            register_offense(node, where_node, where_argument, range)
+            break
+          end
+        end
+
+        private
+
+        def root_receiver(node)
+          parent = node.parent
+          if !parent&.send_type? || parent.method?(:or) || parent.method?(:and)
+            node
+          else
+            root_receiver(parent)
+          end
+        end
+
+        def same_relationship?(where, left_joins)
+          where.value.to_s.match?(/^#{left_joins.value}s?$/)
+        end
+
+        def register_offense(node, where_node, where_argument, range)
+          add_offense(range, message: message(node, where_argument)) do |corrector|
+            corrector.replace(node.loc.selector, 'where.missing')
+            if multi_condition?(where_node.first_argument)
+              replace_where_method(corrector, where_node)
+            else
+              remove_where_method(corrector, node, where_node)
+            end
+          end
+        end
+
+        def replace_where_method(corrector, where_node)
+          missing_relationship(where_node) do |where_clause|
+            corrector.remove(replace_range(where_clause))
+          end
+        end
+
+        def replace_range(child)
+          if (right_sibling = child.right_sibling)
+            range_between(child.source_range.begin_pos, right_sibling.source_range.begin_pos)
+          else
+            range_between(child.left_sibling.source_range.end_pos, child.source_range.end_pos)
+          end
+        end
+
+        def remove_where_method(corrector, node, where_node)
+          range = range_between(where_node.loc.selector.begin_pos, where_node.loc.end.end_pos)
+          if node.multiline? && !same_line?(node, where_node)
+            range = range_by_whole_lines(range, include_final_newline: true)
+          else
+            corrector.remove(where_node.loc.dot)
+          end
+
+          corrector.remove(range)
+        end
+
+        def same_line?(left_joins_node, where_node)
+          left_joins_node.loc.selector.line == where_node.loc.selector.line
+        end
+
+        def multi_condition?(where_arg)
+          where_arg.children.count > 1
+        end
+
+        def message(node, where_argument)
+          format(MSG, left_joins_association: node.first_argument.value, left_joins_method: node.method_name,
+                      where_association: where_argument.value)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/where_not.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies places where manually constructed SQL
+      # in `where` can be replaced with `where.not(...)`.
+      #
+      # @example
+      #   # bad
+      #   User.where('name != ?', 'Gabe')
+      #   User.where('name != :name', name: 'Gabe')
+      #   User.where('name <> ?', 'Gabe')
+      #   User.where('name <> :name', name: 'Gabe')
+      #   User.where('name IS NOT NULL')
+      #   User.where('name NOT IN (?)', ['john', 'jane'])
+      #   User.where('name NOT IN (:names)', names: ['john', 'jane'])
+      #   User.where('users.name != :name', name: 'Gabe')
+      #
+      #   # good
+      #   User.where.not(name: 'Gabe')
+      #   User.where.not(name: nil)
+      #   User.where.not(name: ['john', 'jane'])
+      #   User.where.not(users: { name: 'Gabe' })
+      #
+      class WhereNot < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing negated SQL in `where`.'
+        RESTRICT_ON_SEND = %i[where].freeze
+
+        def_node_matcher :where_method_call?, <<~PATTERN
+          {
+            (send _ :where (array $str_type? $_ ?))
+            (send _ :where $str_type? $_ ?)
+          }
+        PATTERN
+
+        def on_send(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            range = offense_range(node)
+
+            column_and_value = extract_column_and_value(template_node, value_node)
+            return unless column_and_value
+
+            good_method = build_good_method(*column_and_value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
+          end
+        end
+
+        NOT_EQ_ANONYMOUS_RE = /\A([\w.]+)\s+(?:!=|<>)\s+\?\z/.freeze           # column != ?, column <> ?
+        NOT_IN_ANONYMOUS_RE = /\A([\w.]+)\s+NOT\s+IN\s+\(\?\)\z/i.freeze       # column NOT IN (?)
+        NOT_EQ_NAMED_RE     = /\A([\w.]+)\s+(?:!=|<>)\s+:(\w+)\z/.freeze       # column != :column, column <> :column
+        NOT_IN_NAMED_RE     = /\A([\w.]+)\s+NOT\s+IN\s+\(:(\w+)\)\z/i.freeze   # column NOT IN (:column)
+        IS_NOT_NULL_RE      = /\A([\w.]+)\s+IS\s+NOT\s+NULL\z/i.freeze         # column IS NOT NULL
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def extract_column_and_value(template_node, value_node)
+          value =
+            case template_node.value
+            when NOT_EQ_ANONYMOUS_RE, NOT_IN_ANONYMOUS_RE
+              value_node.source
+            when NOT_EQ_NAMED_RE, NOT_IN_NAMED_RE
+              return unless value_node.hash_type?
+
+              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
+              pair.value.source
+            when IS_NOT_NULL_RE
+              'nil'
+            else
+              return
+            end
+
+          [Regexp.last_match(1), value]
+        end
+
+        def build_good_method(column, value)
+          if column.include?('.')
+            table, column = column.split('.')
+
+            "where.not(#{table}: { #{column}: #{value} })"
+          else
+            "where.not(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/where_not_with_multiple_conditions.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies calls to `where.not` with multiple hash arguments.
+      #
+      # The behavior of `where.not` changed in Rails 6.1. Prior to the change,
+      # `.where.not(trashed: true, role: 'admin')` evaluated to
+      # `WHERE trashed != TRUE AND role != 'admin'`.
+      # From Rails 6.1 onwards, this executes the query
+      # `WHERE NOT (trashed == TRUE AND roles == 'admin')`.
+      #
+      # @example
+      #   # bad
+      #   User.where.not(trashed: true, role: 'admin')
+      #   User.where.not(trashed: true, role: ['moderator', 'admin'])
+      #   User.joins(:posts).where.not(posts: { trashed: true, title: 'Rails' })
+      #
+      #   # good
+      #   User.where.not(trashed: true)
+      #   User.where.not(role: ['moderator', 'admin'])
+      #   User.where.not(trashed: true).where.not(role: ['moderator', 'admin'])
+      #   User.where.not('trashed = ? OR role = ?', true, 'admin')
+      class WhereNotWithMultipleConditions < Base
+        MSG = 'Use a SQL statement instead of `where.not` with multiple conditions.'
+        RESTRICT_ON_SEND = %i[not].freeze
+
+        def_node_matcher :where_not_call?, <<~PATTERN
+          (send (send _ :where) :not $...)
+        PATTERN
+
+        def on_send(node)
+          where_not_call?(node) do |args|
+            next unless args[0]&.hash_type?
+            next unless multiple_arguments_hash? args[0]
+
+            range = node.receiver.loc.selector.with(end_pos: node.source_range.end_pos)
+
+            add_offense(range)
+          end
+        end
+
+        private
+
+        def multiple_arguments_hash?(hash)
+          return true if hash.pairs.size >= 2
+          return false unless hash.values[0]&.hash_type?
+
+          multiple_arguments_hash?(hash.values[0])
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -1,64 +1,134 @@
 # frozen_string_literal: true
 
-module RuboCop
-  # RuboCop included the Rails cops directly before version 1.0.0.
-  # We can remove them to avoid warnings about redefining constants.
-  module Cop
-    remove_const('Rails') if const_defined?('Rails')
-  end
-end
-
+require_relative 'mixin/active_record_helper'
+require_relative 'mixin/active_record_migrations_helper'
+require_relative 'mixin/class_send_node_helper'
+require_relative 'mixin/enforce_superclass'
+require_relative 'mixin/index_method'
+require_relative 'mixin/migrations_helper'
 require_relative 'mixin/target_rails_version'
 
+require_relative 'rails/action_controller_flash_before_render'
+require_relative 'rails/action_controller_test_case'
 require_relative 'rails/action_filter'
+require_relative 'rails/action_order'
 require_relative 'rails/active_record_aliases'
+require_relative 'rails/active_record_callbacks_order'
 require_relative 'rails/active_record_override'
 require_relative 'rails/active_support_aliases'
+require_relative 'rails/active_support_on_load'
+require_relative 'rails/add_column_index'
+require_relative 'rails/after_commit_override'
+require_relative 'rails/application_controller'
 require_relative 'rails/application_job'
+require_relative 'rails/application_mailer'
 require_relative 'rails/application_record'
+require_relative 'rails/arel_star'
 require_relative 'rails/assert_not'
+require_relative 'rails/attribute_default_block_value'
 require_relative 'rails/belongs_to'
 require_relative 'rails/blank'
 require_relative 'rails/bulk_change_table'
+require_relative 'rails/compact_blank'
+require_relative 'rails/content_tag'
 require_relative 'rails/create_table_with_timestamps'
 require_relative 'rails/date'
+require_relative 'rails/default_scope'
 require_relative 'rails/delegate'
 require_relative 'rails/delegate_allow_blank'
+require_relative 'rails/deprecated_active_model_errors_methods'
+require_relative 'rails/dot_separated_keys'
+require_relative 'rails/duplicate_association'
+require_relative 'rails/duplicate_scope'
+require_relative 'rails/duration_arithmetic'
 require_relative 'rails/dynamic_find_by'
+require_relative 'rails/eager_evaluation_log_message'
+require_relative 'rails/enum_hash'
 require_relative 'rails/enum_uniqueness'
 require_relative 'rails/environment_comparison'
+require_relative 'rails/environment_variable_access'
 require_relative 'rails/exit'
+require_relative 'rails/expanded_date_range'
 require_relative 'rails/file_path'
 require_relative 'rails/find_by'
+require_relative 'rails/find_by_id'
 require_relative 'rails/find_each'
+require_relative 'rails/freeze_time'
 require_relative 'rails/has_and_belongs_to_many'
 require_relative 'rails/has_many_or_has_one_dependent'
 require_relative 'rails/helper_instance_variable'
 require_relative 'rails/http_positional_arguments'
 require_relative 'rails/http_status'
+require_relative 'rails/i18n_lazy_lookup'
+require_relative 'rails/i18n_locale_assignment'
+require_relative 'rails/i18n_locale_texts'
+require_relative 'rails/ignored_columns_assignment'
 require_relative 'rails/ignored_skip_action_filter_option'
+require_relative 'rails/index_by'
+require_relative 'rails/index_with'
+require_relative 'rails/inquiry'
 require_relative 'rails/inverse_of'
 require_relative 'rails/lexically_scoped_action_filter'
 require_relative 'rails/link_to_blank'
+require_relative 'rails/mailer_name'
+require_relative 'rails/match_route'
+require_relative 'rails/migration_class_name'
+require_relative 'rails/negate_include'
 require_relative 'rails/not_null_column'
+require_relative 'rails/order_by_id'
 require_relative 'rails/output'
 require_relative 'rails/output_safety'
+require_relative 'rails/pick'
+require_relative 'rails/pluck'
+require_relative 'rails/pluck_id'
+require_relative 'rails/pluck_in_where'
 require_relative 'rails/pluralization_grammar'
 require_relative 'rails/presence'
 require_relative 'rails/present'
+require_relative 'rails/rake_environment'
 require_relative 'rails/read_write_attribute'
 require_relative 'rails/redundant_allow_nil'
+require_relative 'rails/redundant_foreign_key'
+require_relative 'rails/redundant_presence_validation_on_belongs_to'
 require_relative 'rails/redundant_receiver_in_with_options'
+require_relative 'rails/redundant_travel_back'
 require_relative 'rails/reflection_class_name'
 require_relative 'rails/refute_methods'
 require_relative 'rails/relative_date_constant'
+require_relative 'rails/render_inline'
+require_relative 'rails/render_plain_text'
 require_relative 'rails/request_referer'
+require_relative 'rails/require_dependency'
+require_relative 'rails/response_parsed_body'
 require_relative 'rails/reversible_migration'
+require_relative 'rails/reversible_migration_method_definition'
+require_relative 'rails/root_join_chain'
+require_relative 'rails/root_pathname_methods'
+require_relative 'rails/root_public_path'
 require_relative 'rails/safe_navigation'
+require_relative 'rails/safe_navigation_with_blank'
 require_relative 'rails/save_bang'
+require_relative 'rails/schema_comment'
 require_relative 'rails/scope_args'
+require_relative 'rails/short_i18n'
 require_relative 'rails/skips_model_validations'
+require_relative 'rails/squished_sql_heredocs'
+require_relative 'rails/strip_heredoc'
+require_relative 'rails/table_name_assignment'
+require_relative 'rails/three_state_boolean_column'
 require_relative 'rails/time_zone'
+require_relative 'rails/time_zone_assignment'
+require_relative 'rails/to_formatted_s'
+require_relative 'rails/to_s_with_argument'
+require_relative 'rails/top_level_hash_with_indifferent_access'
+require_relative 'rails/transaction_exit_statement'
 require_relative 'rails/uniq_before_pluck'
+require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
+require_relative 'rails/unused_ignored_columns'
 require_relative 'rails/validation'
+require_relative 'rails/where_equals'
+require_relative 'rails/where_exists'
+require_relative 'rails/where_missing'
+require_relative 'rails/where_not'
+require_relative 'rails/where_not_with_multiple_conditions'

data/lib/rubocop/rails/inject.rb

@@ -8,7 +8,7 @@ module RuboCop
       def self.defaults!
         path = CONFIG_DEFAULT.to_s
         hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
         puts "configuration from #{path}" if ConfigLoader.debug?
         config = ConfigLoader.merge_with_default(config, path, unset_nil: false)
         ConfigLoader.instance_variable_set(:@default_configuration, config)