rubocop-rails 2.6.0 → 2.9.0

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for uses of `default_scope`.
+      #
+      # @example
+      #   # bad
+      #   default_scope -> { where(hidden: false) }
+      #
+      #   # good
+      #   scope :published, -> { where(hidden: false) }
+      #
+      #   # bad
+      #   def self.default_scope
+      #     where(hidden: false)
+      #   end
+      #
+      #   # good
+      #   def self.published
+      #     where(hidden: false)
+      #   end
+      #
+      class DefaultScope < Base
+        MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
+        RESTRICT_ON_SEND = %i[default_scope].freeze
+
+        def_node_matcher :method_call?, <<~PATTERN
+          (send nil? :default_scope ...)
+        PATTERN
+
+        def_node_matcher :class_method_definition?, <<~PATTERN
+          (defs _ :default_scope args ...)
+        PATTERN
+
+        def_node_matcher :eigenclass_method_definition?, <<~PATTERN
+          (sclass (self) $(def :default_scope args ...))
+        PATTERN
+
+        def on_send(node)
+          return unless method_call?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        def on_defs(node)
+          return unless class_method_definition?(node)
+
+          add_offense(node.loc.name)
+        end
+
+        def on_sclass(node)
+          eigenclass_method_definition?(node) do |default_scope|
+            add_offense(default_scope.loc.name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -52,7 +52,9 @@ module RuboCop
       #
       #   # good
       #   delegate :bar, to: :foo, prefix: true
-      class Delegate < Cop
+      class Delegate < Base
+        extend AutoCorrector
+
         MSG = 'Use `delegate` to define delegations.'
 
         def_node_matcher :delegate?, <<~PATTERN
@@ -64,22 +66,20 @@ module RuboCop
           return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node)
         end
 
-        def autocorrect(node)
-          delegation = ["delegate :#{node.body.method_name}",
-                        "to: :#{node.body.receiver.method_name}"]
+        private
 
-          delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
+        def register_offense(node)
+          add_offense(node.loc.keyword) do |corrector|
+            delegation = ["delegate :#{node.body.method_name}", "to: :#{node.body.receiver.method_name}"]
+            delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
 
-          lambda do |corrector|
             corrector.replace(node.source_range, delegation.join(', '))
           end
         end
 
-        private
-
         def trivial_delegate?(def_node)
           delegate?(def_node) &&
             method_name_matches?(def_node.method_name, def_node.body) &&
@@ -122,7 +122,7 @@ module RuboCop
         end
 
         def private_or_protected_inline(line)
-          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+          processed_source[line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end
     end

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

@@ -13,22 +13,21 @@ module RuboCop
       #
       #   # good
       #   delegate :foo, to: :bar, allow_nil: true
-      class DelegateAllowBlank < Cop
+      class DelegateAllowBlank < Base
+        extend AutoCorrector
+
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
+        RESTRICT_ON_SEND = %i[delegate].freeze
 
         def_node_matcher :allow_blank_option, <<~PATTERN
           (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
         PATTERN
 
         def on_send(node)
-          allow_blank_option(node) do |offending_node|
-            add_offense(offending_node)
-          end
-        end
+          return unless (offending_node = allow_blank_option(node))
 
-        def autocorrect(pair_node)
-          lambda do |corrector|
-            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          add_offense(offending_node) do |corrector|
+            corrector.replace(offending_node.key.source_range, 'allow_nil')
           end
         end
       end

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

@@ -31,7 +31,9 @@ module RuboCop
       #
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
-      class DynamicFindBy < Cop
+      class DynamicFindBy < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
 
@@ -41,26 +43,26 @@ module RuboCop
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
+          return if node.arguments.any?(&:splat_type?)
 
-          add_offense(node,
-                      message: format(MSG, static_name: static_name,
-                                           method: method_name))
+          message = format(MSG, static_name: static_name, method: method_name)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           keywords = column_keywords(node.method_name)
 
           return if keywords.size != node.arguments.size
 
-          lambda do |corrector|
-            autocorrect_method_name(corrector, node)
-            autocorrect_argument_keywords(corrector, node, keywords)
-          end
+          autocorrect_method_name(corrector, node)
+          autocorrect_argument_keywords(corrector, node, keywords)
         end
 
-        private
-
         def allowed_invocation?(node)
           allowed_method?(node) || allowed_receiver?(node) ||
             whitelisted?(node)

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

@@ -17,9 +17,12 @@ module RuboCop
       #   # good
       #   enum status: { active: 0, archived: 1 }
       #
-      class EnumHash < Cop
+      class EnumHash < Base
+        extend AutoCorrector
+
         MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. '\
               'Use hash syntax instead.'
+        RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
           (send nil? :enum (hash $...))
@@ -35,19 +38,17 @@ module RuboCop
               key, array = array_pair?(pair)
               next unless key
 
-              add_offense(array, message: format(MSG, enum: enum_name(key)))
+              add_offense(array, message: format(MSG, enum: enum_name(key))) do |corrector|
+                hash = array.children.each_with_index.map do |elem, index|
+                  "#{source(elem)} => #{index}"
+                end.join(', ')
+
+                corrector.replace(array.loc.expression, "{#{hash}}")
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          hash = node.children.each_with_index.map do |elem, index|
-            "#{source(elem)} => #{index}"
-          end.join(', ')
-
-          ->(corrector) { corrector.replace(node.loc.expression, "{#{hash}}") }
-        end
-
         private
 
         def enum_name(key)

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

@@ -17,11 +17,12 @@ module RuboCop
       #
       #   # good
       #   enum status: [:active, :archived]
-      class EnumUniqueness < Cop
+      class EnumUniqueness < Base
         include Duplication
 
         MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
               'enum declaration.'
+        RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
           (send nil? :enum (hash $...))

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

@@ -15,12 +15,16 @@ module RuboCop
       #
       #   # good
       #   Rails.env.production?
-      class EnvironmentComparison < Cop
+      class EnvironmentComparison < Base
+        extend AutoCorrector
+
         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`.'
 
+        RESTRICT_ON_SEND = %i[== !=].freeze
+
         def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
           (send
             (send (const {nil? cbase} :Rails) :env)
@@ -62,28 +66,28 @@ module RuboCop
                          comparing_str_env_with_rails_env_on_rhs?(node))
             env, = *env_node
             bang = node.method?(:!=) ? '!' : ''
+            message = format(MSG, bang: bang, env: env, source: node.source)
 
-            add_offense(node, message: format(
-              MSG, bang: bang, env: env, source: node.source
-            ))
-          end
-
-          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)
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
-        end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = build_predicate_method(node)
+          return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
 
-            corrector.replace(node.source_range, replacement)
+          add_offense(node, message: SYM_MSG) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          replacement = build_predicate_method(node)
+
+          corrector.replace(node.source_range, replacement)
+        end
+
         def build_predicate_method(node)
           if rails_env_on_lhs?(node)
             build_predicate_method_for_rails_env_on_lhs(node)

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

@@ -23,27 +23,21 @@ module RuboCop
       #
       #   # good
       #   raise 'a bad error has happened'
-      class Exit < Cop
+      class Exit < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `exit` in Rails applications.'
-        TARGET_METHODS = %i[exit exit!].freeze
+        RESTRICT_ON_SEND = %i[exit exit!].freeze
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
+          add_offense(node.loc.selector) if offending_node?(node)
         end
 
         private
 
         def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
+          right_argument_count?(node.arguments) && right_receiver?(node.receiver)
         end
 
         # More than 1 argument likely means it is a different

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

@@ -25,7 +25,7 @@ module RuboCop
       #   # good
       #   Rails.root.join('app/models/goober')
       #
-      class FilePath < Cop
+      class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
@@ -33,6 +33,7 @@ module RuboCop
                       'instead.'
         MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
                         'instead.'
+        RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
           (send (const nil? :File) :join ...)
@@ -90,17 +91,17 @@ module RuboCop
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
+          node.str_type? && node.source.include?('/')
         end
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
           source_range = source_range(processed_source.buffer, node.first_line,
                                       line_range)
-          add_offense(node, location: source_range)
+          add_offense(source_range)
         end
 
-        def message(_node)
+        def message(_range)
           format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
         end
       end

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

@@ -13,11 +13,12 @@ module RuboCop
       #
       #   # good
       #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
+      class FindBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
+        RESTRICT_ON_SEND = %i[first take].freeze
 
         def_node_matcher :where_first?, <<~PATTERN
           (send ({send csend} _ :where ...) {:first :take})
@@ -26,28 +27,27 @@ module RuboCop
         def on_send(node)
           return unless where_first?(node)
 
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
+          range = range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
 
-          add_offense(node, location: range,
-                            message: format(MSG, method: node.method_name))
+          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           # Don't autocorrect where(...).first, because it can return different
           # results from find_by. (They order records differently, so the
           # 'first' record can be different.)
           return if node.method?(:first)
 
           where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos,
-                                    node.loc.selector.end_pos)
+          first_loc = range_between(node.loc.dot.begin_pos, node.loc.selector.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(where_loc, 'find_by')
-            corrector.replace(first_loc, '')
-          end
+          corrector.replace(where_loc, 'find_by')
+          corrector.replace(first_loc, '')
         end
       end
     end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that `ActiveRecord#find` is used instead of
+      # `where.take!`, `find_by!`, and `find_by_id!` to retrieve a single record
+      # by primary key when you expect it to be found.
+      #
+      # @example
+      #   # bad
+      #   User.where(id: id).take!
+      #   User.find_by_id!(id)
+      #   User.find_by!(id: id)
+      #
+      #   # good
+      #   User.find(id)
+      #
+      class FindById < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
+
+        def_node_matcher :where_take?, <<~PATTERN
+          (send
+            $(send _ :where
+              (hash
+                (pair (sym :id) $_))) :take!)
+        PATTERN
+
+        def_node_matcher :find_by?, <<~PATTERN
+          {
+            (send _ :find_by_id! $_)
+            (send _ :find_by! (hash (pair (sym :id) $_)))
+          }
+        PATTERN
+
+        def on_send(node)
+          where_take?(node) do |where, id_value|
+            range = where_take_offense_range(node, where)
+            bad_method = build_where_take_bad_method(id_value)
+
+            register_offense(range, id_value, bad_method)
+          end
+
+          find_by?(node) do |id_value|
+            range = find_by_offense_range(node)
+            bad_method = build_find_by_bad_method(node, id_value)
+
+            register_offense(range, id_value, bad_method)
+          end
+        end
+
+        private
+
+        def register_offense(range, id_value, bad_method)
+          good_method = build_good_method(id_value)
+          message = format(MSG, good_method: good_method, bad_method: bad_method)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good_method)
+          end
+        end
+
+        def where_take_offense_range(node, where)
+          range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def find_by_offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def build_good_method(id_value)
+          "find(#{id_value.source})"
+        end
+
+        def build_where_take_bad_method(id_value)
+          "where(id: #{id_value.source}).take!"
+        end
+
+        def build_find_by_bad_method(node, id_value)
+          case node.method_name
+          when :find_by_id!
+            "find_by_id!(#{id_value.source})"
+          when :find_by!
+            "find_by!(id: #{id_value.source})"
+          end
+        end
+      end
+    end
+  end
+end