rubocop-rails 2.4.2 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cf251ed7e29a11391396009eb82eed3fa4684e100b26b9041d469da2db04133
-  data.tar.gz: 440778968fbafa4dd3415741d8ef3c49e6025bee7ec85454a5b7012859e657c4
+  metadata.gz: fd5bcec81363b7952d67bc476f82e25fbe0e0a8e4eb62e490712ddb5cfb58807
+  data.tar.gz: 0eeec3b789aed712f41d0f842620ec0fd871dc884fe791819256b5777a0edb9d
 SHA512:
-  metadata.gz: fe54c2657de98b317f8df85618a4a00708be71dc8c7c924a43734773a1f3d31da6d85e44cbb983f5c10ecb235bf420ac86a4e67ac86a45b70e7c9b8403f4623e
-  data.tar.gz: 4c9111285fe0211b5b1da14f8b31d2023a20e3b223dee3a1a3fcec0c66e622a0116ec783059a5161042640f92799b4df2b7585a4dd0ac96f12b06fa776886960
+  metadata.gz: 4fb1e35ca0fab64ed16959e29d2144b5cb9aafaf5064d04c67f1bee3cba9eaa4cc2c7c87b71dc240d10c1d11a8361ccacb3cb7002b9e14ef0a3908bfe271f79d
+  data.tar.gz: 108de4501d9f50c50d7d3e23c93574a1a2eee389d5abef80b7e9982d3d7dba524dc263cf76986ae3caa1ab202fc4c7b20ce8106ac82dab5c43e7a578f4fe04ef

data/README.md

@@ -76,6 +76,10 @@ Rails/FindBy:
     - lib/example.rb
 ```
 
+## Documentation
+
+You can read a lot more about RuboCop Rails in its [official docs](https://docs.rubocop.org/projects/rails/).
+
 ## Compatibility
 
 Rails cops support the following versions:

data/config/default.yml

@@ -268,6 +268,16 @@ Rails/IgnoredSkipActionFilterOption:
   Include:
     - app/controllers/**/*.rb
 
+Rails/IndexBy:
+  Description: 'Prefer `index_by` over `each_with_object` or `map`.'
+  Enabled: true
+  VersionAdded: '2.5'
+
+Rails/IndexWith:
+  Description: 'Prefer `index_with` over `each_with_object` or `map`.'
+  Enabled: true
+  VersionAdded: '2.5'
+
 Rails/InverseOf:
   Description: 'Checks for associations where the inverse cannot be determined automatically.'
   Enabled: true
@@ -346,6 +356,8 @@ Rails/RakeEnvironment:
   Include:
     - '**/Rakefile'
     - '**/*.rake'
+  Exclude:
+    - 'lib/capistrano/tasks/**/*.rake'
 
 Rails/ReadWriteAttribute:
   Description: >-
@@ -381,6 +393,10 @@ Rails/RefuteMethods:
   Description: 'Use `assert_not` methods instead of `refute` methods.'
   Enabled: true
   VersionAdded: '0.56'
+  EnforcedStyle: assert_not
+  SupportedStyles:
+    - assert_not
+    - refute
   Include:
     - '**/test/**/*'
 
@@ -496,6 +512,13 @@ Rails/UniqBeforePluck:
     - aggressive
   AutoCorrect: false
 
+Rails/UniqueValidationWithoutIndex:
+  Description: 'Uniqueness validation should be with a unique index.'
+  Enabled: true
+  VersionAdded: '2.5'
+  Include:
+    - app/models/**/*.rb
+
 Rails/UnknownEnv:
   Description: 'Use correct environment name.'
   Enabled: true

data/lib/rubocop-rails.rb

@@ -2,10 +2,13 @@
 
 require 'rubocop'
 require 'rack/utils'
+require 'active_support/inflector'
 
 require_relative 'rubocop/rails'
 require_relative 'rubocop/rails/version'
 require_relative 'rubocop/rails/inject'
+require_relative 'rubocop/rails/schema_loader'
+require_relative 'rubocop/rails/schema_loader/schema'
 
 RuboCop::Rails::Inject.defaults!
 

data/lib/rubocop/cop/mixin/active_record_helper.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # A mixin to extend cops for Active Record features
+    module ActiveRecordHelper
+      extend NodePattern::Macros
+
+      def_node_search :find_set_table_name, <<~PATTERN
+        (send self :table_name= {str sym})
+      PATTERN
+
+      def_node_search :find_belongs_to, <<~PATTERN
+        (send nil? :belongs_to {str sym} ...)
+      PATTERN
+
+      def table_name(class_node)
+        table_name = find_set_table_name(class_node).to_a.last&.first_argument
+        return table_name.value.to_s if table_name
+
+        namespaces = class_node.each_ancestor(:class, :module)
+        [class_node, *namespaces]
+          .reverse
+          .map { |klass| klass.identifier.children[1] }.join('_')
+          .tableize
+      end
+
+      # Resolve relation into column name.
+      # It just returns column_name if the column exists.
+      # Or it tries to resolve column_name as a relation.
+      # It returns `nil` if it can't resolve.
+      #
+      # @param name [String]
+      # @param class_node [RuboCop::AST::Node]
+      # @param table [RuboCop::Rails::SchemaLoader::Table]
+      # @return [String, nil]
+      def resolve_relation_into_column(name:, class_node:, table:)
+        return name if table.with_column?(name: name)
+
+        find_belongs_to(class_node) do |belongs_to|
+          next unless belongs_to.first_argument.value.to_s == name
+
+          fk = foreign_key_of(belongs_to) || "#{name}_id"
+          return fk if table.with_column?(name: fk)
+        end
+        nil
+      end
+
+      def foreign_key_of(belongs_to)
+        options = belongs_to.last_argument
+        return unless options.hash_type?
+
+        options.each_pair.find do |pair|
+          next unless pair.key.sym_type? && pair.key.value == :foreign_key
+          next unless pair.value.sym_type? || pair.value.str_type?
+
+          break pair.value.value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/index_method.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails/IndexBy and Rails/IndexWith
+    module IndexMethod # rubocop:disable Metrics/ModuleLength
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[map { ... }]')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map { ... }.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        return if captures.noop_transformation?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      def extract_captures(match)
+        argname, body_expr = *match
+        Captures.new(argname, body_expr)
+      end
+
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = node.parent&.block_type? ? 0 : '.to_h'.length
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object` case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body.loc.expression,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -16,52 +16,98 @@ module RuboCop
       #   # good
       #   Rails.env.production?
       class EnvironmentComparison < Cop
-        MSG = "Favor `Rails.env.%<env>s?` over `Rails.env == '%<env>s'`."
+        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
 
         SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always ' \
           'evaluate to `false`.'
 
-        def_node_matcher :environment_str_comparison?, <<~PATTERN
+        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
-            :==
+            {:== :!=}
             $str
           )
         PATTERN
 
-        def_node_matcher :environment_sym_comparison?, <<~PATTERN
+        def_node_matcher :comparing_str_env_with_rails_env_on_rhs?, <<~PATTERN
+          (send
+            $str
+            {:== :!=}
+            (send (const {nil? cbase} :Rails) :env)
+          )
+        PATTERN
+
+        def_node_matcher :comparing_sym_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
-            :==
+            {:== :!=}
             $sym
           )
         PATTERN
 
+        def_node_matcher :comparing_sym_env_with_rails_env_on_rhs?, <<~PATTERN
+          (send
+            $sym
+            {:== :!=}
+            (send (const {nil? cbase} :Rails) :env)
+          )
+        PATTERN
+
+        def_node_matcher :content, <<~PATTERN
+          ({str sym} $_)
+        PATTERN
+
         def on_send(node)
-          environment_str_comparison?(node) do |env_node|
+          if (env_node = comparing_str_env_with_rails_env_on_lhs?(node) ||
+                         comparing_str_env_with_rails_env_on_rhs?(node))
             env, = *env_node
-            add_offense(node, message: format(MSG, env: env))
+            bang = node.method?(:!=) ? '!' : ''
+
+            add_offense(node, message: format(
+              MSG, bang: bang, env: env, source: node.source
+            ))
           end
-          environment_sym_comparison?(node) do |_|
+
+          if comparing_sym_env_with_rails_env_on_lhs?(node) ||
+             comparing_sym_env_with_rails_env_on_rhs?(node)
             add_offense(node, message: SYM_MSG)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, replacement(node))
+            replacement = build_predicate_method(node)
+
+            corrector.replace(node.source_range, replacement)
           end
         end
 
         private
 
-        def replacement(node)
-          "#{node.receiver.source}.#{content(node.first_argument)}?"
+        def build_predicate_method(node)
+          if rails_env_on_lhs?(node)
+            build_predicate_method_for_rails_env_on_lhs(node)
+          else
+            build_predicate_method_for_rails_env_on_rhs(node)
+          end
         end
 
-        def_node_matcher :content, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
+        def rails_env_on_lhs?(node)
+          comparing_str_env_with_rails_env_on_lhs?(node) ||
+            comparing_sym_env_with_rails_env_on_lhs?(node)
+        end
+
+        def build_predicate_method_for_rails_env_on_lhs(node)
+          bang = node.method?(:!=) ? '!' : ''
+
+          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
+        end
+
+        def build_predicate_method_for_rails_env_on_rhs(node)
+          bang = node.method?(:!=) ? '!' : ''
+
+          "#{bang}#{node.first_argument.source}.#{content(node.receiver)}?"
+        end
       end
     end
   end

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%<verb>s`.'
         KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env
+          method params session body flash xhr as headers env to
         ].freeze
         HTTP_METHODS = %i[get post put patch delete head].freeze
 

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the values are the original elements.
+      # Rails provides the `index_by` method for this purpose.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
+      #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
+      #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
+      #
+      #   # good
+      #   [1, 2, 3].index_by { |el| foo(el) }
+      class IndexBy < Cop
+        include IndexMethod
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend} _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            ({send csend} (lvar _memo) :[]= $_ (lvar _el)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el)))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array $_ (lvar _el))))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_by'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
+      # an enumerable into a hash where the keys are the original elements.
+      # Rails provides the `index_with` method for this purpose.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }
+      #   [1, 2, 3].map { |el| [el, foo(el)] }.to_h
+      #   Hash[[1, 2, 3].collect { |el| [el, foo(el)] }]
+      #
+      #   # good
+      #   [1, 2, 3].index_with { |el| foo(el) }
+      class IndexWith < Cop
+        extend TargetRailsVersion
+        include IndexMethod
+
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend} _ :each_with_object (hash))
+            (args (arg $_el) (arg _memo))
+            ({send csend} (lvar _memo) :[]= (lvar _el) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_))
+            :to_h)
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} _ {:map :collect})
+              (args (arg $_el))
+              (array (lvar _el) $_)))
+        PATTERN
+
+        private
+
+        def new_method_name
+          'index_with'
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
       #
       # Use `assert_not` methods instead of `refute` methods.
       #
-      # @example
+      # @example EnforcedStyle: assert_not (default)
       #   # bad
       #   refute false
       #   refute_empty [1, 2, 3]
@@ -17,29 +17,43 @@ module RuboCop
       #   assert_not_empty [1, 2, 3]
       #   assert_not_equal true, false
       #
+      # @example EnforcedStyle: refute
+      #   # bad
+      #   assert_not false
+      #   assert_not_empty [1, 2, 3]
+      #   assert_not_equal true, false
+      #
+      #   # good
+      #   refute false
+      #   refute_empty [1, 2, 3]
+      #   refute_equal true, false
+      #
       class RefuteMethods < Cop
-        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
         CORRECTIONS = {
-          refute:             'assert_not',
-          refute_empty:       'assert_not_empty',
-          refute_equal:       'assert_not_equal',
-          refute_in_delta:    'assert_not_in_delta',
-          refute_in_epsilon:  'assert_not_in_epsilon',
-          refute_includes:    'assert_not_includes',
-          refute_instance_of: 'assert_not_instance_of',
-          refute_kind_of:     'assert_not_kind_of',
-          refute_nil:         'assert_not_nil',
-          refute_operator:    'assert_not_operator',
-          refute_predicate:   'assert_not_predicate',
-          refute_respond_to:  'assert_not_respond_to',
-          refute_same:        'assert_not_same',
-          refute_match:       'assert_no_match'
+          refute:             :assert_not,
+          refute_empty:       :assert_not_empty,
+          refute_equal:       :assert_not_equal,
+          refute_in_delta:    :assert_not_in_delta,
+          refute_in_epsilon:  :assert_not_in_epsilon,
+          refute_includes:    :assert_not_includes,
+          refute_instance_of: :assert_not_instance_of,
+          refute_kind_of:     :assert_not_kind_of,
+          refute_nil:         :assert_not_nil,
+          refute_operator:    :assert_not_operator,
+          refute_predicate:   :assert_not_predicate,
+          refute_respond_to:  :assert_not_respond_to,
+          refute_same:        :assert_not_same,
+          refute_match:       :assert_no_match
         }.freeze
 
-        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
+        REFUTE_METHODS = CORRECTIONS.keys.freeze
+        ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
 
-        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
+        def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
 
         def on_send(node)
           return unless offensive?(node)
@@ -49,27 +63,39 @@ module RuboCop
         end
 
         def autocorrect(node)
+          bad_method = node.method_name
+          good_method = convert_good_method(bad_method)
+
           lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              CORRECTIONS[node.method_name]
-            )
+            corrector.replace(node.loc.selector, good_method.to_s)
           end
         end
 
         private
 
-        def refute_method?(method_name)
-          OFFENSIVE_METHODS.include?(method_name)
+        def bad_method?(method_name)
+          if style == :assert_not
+            REFUTE_METHODS.include?(method_name)
+          else
+            ASSERT_NOT_METHODS.include?(method_name)
+          end
         end
 
         def offense_message(method_name)
           format(
             MSG,
-            refute_method: method_name,
-            assert_method: CORRECTIONS[method_name]
+            bad_method: method_name,
+            good_method: convert_good_method(method_name)
           )
         end
+
+        def convert_good_method(bad_method)
+          if style == :assert_not
+            CORRECTIONS.fetch(bad_method)
+          else
+            CORRECTIONS.invert.fetch(bad_method)
+          end
+        end
       end
     end
   end

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

@@ -90,6 +90,11 @@ module RuboCop
       #     remove_foreign_key :accounts, :branches
       #   end
       #
+      #   # good
+      #   def change
+      #     remove_foreign_key :accounts, to_table: :branches
+      #   end
+      #
       # @example
       #   # change_table
       #
@@ -210,7 +215,7 @@ module RuboCop
 
         def check_remove_foreign_key_node(node)
           remove_foreign_key_call(node) do |arg|
-            if arg.hash_type?
+            if arg.hash_type? && !all_hash_key?(arg, :to_table)
               add_offense(
                 node,
                 message: format(MSG,

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

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # When you define a uniqueness validation in Active Record model,
+      # you also should add a unique index for the column. There are two reasons
+      # First, duplicated records may occur even if Active Record's validation
+      # is defined.
+      # Second, it will cause slow queries. The validation executes a `SELECT`
+      # statement with the target column when inserting/updating a record.
+      # If the column does not have an index and the table is large,
+      # the query will be heavy.
+      #
+      # Note that the cop does nothing if db/schema.rb does not exist.
+      #
+      # @example
+      #   # bad - if the schema does not have a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - if the schema has a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - even if the schema does not have a unique index
+      #   validates :account, length: { minimum: MIN_LENGTH }
+      #
+      class UniqueValidationWithoutIndex < Cop
+        include ActiveRecordHelper
+
+        MSG = 'Uniqueness validation should be with a unique index.'
+
+        def on_send(node)
+          return unless node.method?(:validates)
+          return unless uniqueness_part(node)
+          return unless schema
+          return if with_index?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def with_index?(node)
+          klass = class_node(node)
+          return true unless klass # Skip analysis
+
+          table = schema.table_by(name: table_name(klass))
+          return true unless table # Skip analysis if it can't find the table
+
+          names = column_names(node)
+          return true unless names
+
+          table.indices.any? do |index|
+            index.unique && index.columns.to_set == names
+          end
+        end
+
+        def column_names(node)
+          arg = node.first_argument
+          return unless arg.str_type? || arg.sym_type?
+
+          ret = [arg.value]
+          names_from_scope = column_names_from_scope(node)
+          ret.concat(names_from_scope) if names_from_scope
+
+          ret.map! do |name|
+            klass = class_node(node)
+            resolve_relation_into_column(
+              name: name.to_s,
+              class_node: klass,
+              table: schema.table_by(name: table_name(klass))
+            )
+          end
+          ret.include?(nil) ? nil : ret.to_set
+        end
+
+        def column_names_from_scope(node)
+          uniq = uniqueness_part(node)
+          return unless uniq.hash_type?
+
+          scope = find_scope(uniq)
+          return unless scope
+
+          case scope.type
+          when :sym, :str
+            [scope.value]
+          when :array
+            array_node_to_array(scope)
+          end
+        end
+
+        def find_scope(pairs)
+          pairs.each_pair.find do |pair|
+            key = pair.key
+            next unless key.sym_type? && key.value == :scope
+
+            break pair.value
+          end
+        end
+
+        def class_node(node)
+          node.each_ancestor.find(&:class_type?)
+        end
+
+        def uniqueness_part(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair.find do |pair|
+            next unless pair.key.sym_type? && pair.key.value == :uniqueness
+
+            break pair.value
+          end
+        end
+
+        def array_node_to_array(node)
+          node.values.map do |elm|
+            case elm.type
+            when :str, :sym
+              elm.value
+            else
+              return nil
+            end
+          end
+        end
+
+        def schema
+          RuboCop::Rails::SchemaLoader.load(target_ruby_version)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'mixin/active_record_helper'
+require_relative 'mixin/index_method'
 require_relative 'mixin/target_rails_version'
 
 require_relative 'rails/action_filter'
@@ -32,6 +34,8 @@ require_relative 'rails/helper_instance_variable'
 require_relative 'rails/http_positional_arguments'
 require_relative 'rails/http_status'
 require_relative 'rails/ignored_skip_action_filter_option'
+require_relative 'rails/index_by'
+require_relative 'rails/index_with'
 require_relative 'rails/inverse_of'
 require_relative 'rails/lexically_scoped_action_filter'
 require_relative 'rails/link_to_blank'
@@ -57,5 +61,6 @@ require_relative 'rails/scope_args'
 require_relative 'rails/skips_model_validations'
 require_relative 'rails/time_zone'
 require_relative 'rails/uniq_before_pluck'
+require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
 require_relative 'rails/validation'

data/lib/rubocop/rails/schema_loader.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rails
+    # It loads db/schema.rb and return Schema object.
+    # Cops refers database schema information with this module.
+    module SchemaLoader
+      extend self
+
+      # It parses `db/schema.rb` and return it.
+      # It returns `nil` if it can't find `db/schema.rb`.
+      # So a cop that uses the loader should handle `nil` properly.
+      #
+      # @return [Schema, nil]
+      def load(target_ruby_version)
+        return @schema if defined?(@schema)
+
+        @schema = load!(target_ruby_version)
+      end
+
+      def reset!
+        return unless instance_variable_defined?(:@schema)
+
+        remove_instance_variable(:@schema)
+      end
+
+      private
+
+      def load!(target_ruby_version)
+        path = db_schema_path
+        return unless path
+
+        ast = parse(path, target_ruby_version)
+        Schema.new(ast)
+      end
+
+      def db_schema_path
+        path = Pathname.pwd
+        until path.root?
+          schema_path = path.join('db/schema.rb')
+          return schema_path if schema_path.exist?
+
+          path = path.join('../').cleanpath
+        end
+
+        nil
+      end
+
+      def parse(path, target_ruby_version)
+        klass_name = :"Ruby#{target_ruby_version.to_s.sub('.', '')}"
+        klass = ::Parser.const_get(klass_name)
+        parser = klass.new(RuboCop::AST::Builder.new)
+
+        buffer = Parser::Source::Buffer.new(path, 1)
+        buffer.source = path.read
+
+        parser.parse(buffer)
+      end
+    end
+  end
+end

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rails
+    module SchemaLoader
+      # Represent db/schema.rb
+      class Schema
+        attr_reader :tables
+
+        def initialize(ast)
+          @tables = []
+          build!(ast)
+        end
+
+        def table_by(name:)
+          tables.find do |table|
+            table.name == name
+          end
+        end
+
+        private
+
+        def build!(ast)
+          raise "Unexpected type: #{ast.type}" unless ast.block_type?
+
+          each_table(ast) do |table_def|
+            @tables << Table.new(table_def)
+          end
+        end
+
+        def each_table(ast)
+          case ast.body.type
+          when :begin
+            ast.body.children.each do |node|
+              next unless node.block_type? && node.method?(:create_table)
+
+              yield(node)
+            end
+          else
+            yield ast.body
+          end
+        end
+      end
+
+      # Reprecent a table
+      class Table
+        attr_reader :name, :columns, :indices
+
+        def initialize(node)
+          @name = node.send_node.first_argument.value
+          @columns = build_columns(node)
+          @indices = build_indices(node)
+        end
+
+        def with_column?(name:)
+          @columns.any? { |c| c.name == name }
+        end
+
+        private
+
+        def build_columns(node)
+          each_content(node).map do |child|
+            next unless child.send_type?
+            next if child.method?(:index)
+
+            Column.new(child)
+          end.compact
+        end
+
+        def build_indices(node)
+          each_content(node).map do |child|
+            next unless child.send_type?
+            next unless child.method?(:index)
+
+            Index.new(child)
+          end.compact
+        end
+
+        def each_content(node)
+          return enum_for(__method__, node) unless block_given?
+
+          case node.body.type
+          when :begin
+            node.body.children.each do |child|
+              yield(child)
+            end
+          else
+            yield(node.body)
+          end
+        end
+      end
+
+      # Reprecent a column
+      class Column
+        attr_reader :name, :type, :not_null
+
+        def initialize(node)
+          @name = node.first_argument.value
+          @type = node.method_name
+          @not_null = nil
+
+          analyze_keywords!(node)
+        end
+
+        private
+
+        def analyze_keywords!(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair do |k, v|
+            if k.value == :null
+              @not_null = v.true_type? ? false : true
+            end
+          end
+        end
+      end
+
+      # Reprecent an index
+      class Index
+        attr_reader :name, :columns, :expression, :unique
+
+        def initialize(node)
+          node.first_argument
+          @columns, @expression = build_columns_or_expr(node)
+          @unique = nil
+
+          analyze_keywords!(node)
+        end
+
+        private
+
+        def build_columns_or_expr(node)
+          arg = node.first_argument
+          if arg.array_type?
+            [arg.values.map(&:value), nil]
+          else
+            [[], arg.value]
+          end
+        end
+
+        def analyze_keywords!(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair do |k, v|
+            case k.value
+            when :name
+              @name = v.value
+            when :unique
+              @unique = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.4.2'
+      STRING = '2.5.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.4.2
+  version: 2.5.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,8 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-26 00:00:00.000000000 Z
+date: 2020-03-23 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -55,6 +69,8 @@ files:
 - bin/setup
 - config/default.yml
 - lib/rubocop-rails.rb
+- lib/rubocop/cop/mixin/active_record_helper.rb
+- lib/rubocop/cop/mixin/index_method.rb
 - lib/rubocop/cop/mixin/target_rails_version.rb
 - lib/rubocop/cop/rails/action_filter.rb
 - lib/rubocop/cop/rails/active_record_aliases.rb
@@ -86,6 +102,8 @@ files:
 - lib/rubocop/cop/rails/http_positional_arguments.rb
 - lib/rubocop/cop/rails/http_status.rb
 - lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb
+- lib/rubocop/cop/rails/index_by.rb
+- lib/rubocop/cop/rails/index_with.rb
 - lib/rubocop/cop/rails/inverse_of.rb
 - lib/rubocop/cop/rails/lexically_scoped_action_filter.rb
 - lib/rubocop/cop/rails/link_to_blank.rb
@@ -111,20 +129,23 @@ files:
 - lib/rubocop/cop/rails/skips_model_validations.rb
 - lib/rubocop/cop/rails/time_zone.rb
 - lib/rubocop/cop/rails/uniq_before_pluck.rb
+- lib/rubocop/cop/rails/unique_validation_without_index.rb
 - lib/rubocop/cop/rails/unknown_env.rb
 - lib/rubocop/cop/rails/validation.rb
 - lib/rubocop/cop/rails_cops.rb
 - lib/rubocop/rails.rb
 - lib/rubocop/rails/inject.rb
+- lib/rubocop/rails/schema_loader.rb
+- lib/rubocop/rails/schema_loader/schema.rb
 - lib/rubocop/rails/version.rb
 homepage: https://github.com/rubocop-hq/rubocop-rails
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://docs.rubocop.org/projects/rails
+  homepage_uri: https://docs.rubocop.org/projects/rails/
   changelog_uri: https://github.com/rubocop-hq/rubocop-rails/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop-hq/rubocop-rails/
-  documentation_uri: https://docs.rubocop.org/projects/rails
+  documentation_uri: https://docs.rubocop.org/projects/rails/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-rails/issues
 post_install_message: 
 rdoc_options: []