rubocop-rails 2.5.2 → 2.8.1

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

@@ -9,11 +9,11 @@ module RuboCop
       #
       # There are two obvious cases where `exit` is particularly harmful:
       #
-      # - Usage in library code for your application. Even though Rails will
+      # * Usage in library code for your application. Even though Rails will
       # rescue from a `SystemExit` and continue on, unit testing that library
       # code will result in specs exiting (potentially silently if `exit(0)`
       # is used.)
-      # - Usage in application code outside of the web process could result in
+      # * Usage in application code outside of the web process could result in
       # the program exiting, which could result in the code failing to run and
       # do its job.
       #

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

@@ -48,6 +48,7 @@ module RuboCop
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
+          return unless node.children.last.str_type?
           return unless node.children.last.source.start_with?('.') ||
                         node.children.last.source.include?(File::SEPARATOR)
 
@@ -89,7 +90,7 @@ 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)

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

@@ -0,0 +1,103 @@
+# 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 < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        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)
+
+            good_method = build_good_method(id_value)
+            bad_method = build_where_take_bad_method(id_value)
+            message = format(MSG, good_method: good_method, bad_method: bad_method)
+
+            add_offense(node, location: range, message: message)
+          end
+
+          find_by?(node) do |id_value|
+            range = find_by_offense_range(node)
+
+            good_method = build_good_method(id_value)
+            bad_method = build_find_by_bad_method(node, id_value)
+            message = format(MSG, good_method: good_method, bad_method: bad_method)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          if (matches = where_take?(node))
+            where, id_value = *matches
+            range = where_take_offense_range(node, where)
+          elsif (id_value = find_by?(node))
+            range = find_by_offense_range(node)
+          end
+
+          lambda do |corrector|
+            replacement = build_good_method(id_value)
+            corrector.replace(range, replacement)
+          end
+        end
+
+        private
+
+        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

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

@@ -52,11 +52,7 @@ module RuboCop
 
         def on_send(node)
           return if active_resource?(node.parent)
-
-          unless association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          end
-
+          return if !association_without_options?(node) && valid_options?(association_with_options?(node))
           return if valid_options_in_with_options_block?(node)
 
           add_offense(node, location: :selector)

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

@@ -31,6 +31,8 @@ module RuboCop
         end
 
         def on_ivasgn(node)
+          return if node.parent.or_asgn_type?
+
           add_offense(node, location: :name)
         end
       end

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

@@ -8,7 +8,7 @@ module RuboCop
       # change them to use keyword args. This cop only applies to Rails >= 5.
       # If you are running Rails < 5 you should disable the
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
-      # .rubocop.yml file to 4.0, etc.
+      # .rubocop.yml file to 4.2.
       #
       # @example
       #   # bad
@@ -16,6 +16,7 @@ module RuboCop
       #
       #   # good
       #   get :new, params: { user_id: 1 }
+      #   get :new, **options
       class HttpPositionalArguments < Cop
         extend TargetRailsVersion
 
@@ -32,6 +33,10 @@ module RuboCop
           (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
         PATTERN
 
+        def_node_matcher :kwsplat_hash?, <<~PATTERN
+          (hash (kwsplat _))
+        PATTERN
+
         def on_send(node)
           http_request?(node) do |data|
             return unless needs_conversion?(data)
@@ -61,6 +66,7 @@ module RuboCop
 
         def needs_conversion?(data)
           return true unless data.hash_type?
+          return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
             special_keyword_arg?(pair.key) ||

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

@@ -83,6 +83,7 @@ module RuboCop
                         'to define HTTP status code.'
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end
@@ -124,6 +125,7 @@ module RuboCop
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node
+
           def initialize(node)
             @node = node
           end

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

@@ -11,6 +11,7 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].each_with_object({}) { |el, h| h[foo(el)] = el }
+      #   [1, 2, 3].to_h { |el| [foo(el), el] }
       #   [1, 2, 3].map { |el| [foo(el), el] }.to_h
       #   Hash[[1, 2, 3].collect { |el| [foo(el), el] }]
       #
@@ -23,7 +24,14 @@ module RuboCop
           (block
             ({send csend} _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= $_ (lvar _el)))
+            ({send csend} (lvar _memo) :[]= $!`_memo (lvar _el)))
+        PATTERN
+
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} _ :to_h)
+            (args (arg $_el))
+            (array $_ (lvar _el)))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN

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

@@ -11,6 +11,7 @@ module RuboCop
       # @example
       #   # bad
       #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }
+      #   [1, 2, 3].to_h { |el| [el, foo(el)] }
       #   [1, 2, 3].map { |el| [el, foo(el)] }.to_h
       #   Hash[[1, 2, 3].collect { |el| [el, foo(el)] }]
       #
@@ -26,7 +27,14 @@ module RuboCop
           (block
             ({send csend} _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= (lvar _el) $_))
+            ({send csend} (lvar _memo) :[]= (lvar _el) $!`_memo))
+        PATTERN
+
+        def_node_matcher :on_bad_to_h, <<~PATTERN
+          (block
+            ({send csend} _ :to_h)
+            (args (arg $_el))
+            (array (lvar _el) $_))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that Active Support's `inquiry` method is not used.
+      #
+      # @example
+      #   # bad - String#inquiry
+      #   ruby = 'two'.inquiry
+      #   ruby.two?
+      #
+      #   # good
+      #   ruby = 'two'
+      #   ruby == 'two'
+      #
+      #   # bad - Array#inquiry
+      #   pets = %w(cat dog).inquiry
+      #   pets.gopher?
+      #
+      #   # good
+      #   pets = %w(cat dog)
+      #   pets.include? 'cat'
+      #
+      class Inquiry < Cop
+        MSG = "Prefer Ruby's comparison operators over Active Support's `inquiry`."
+
+        def on_send(node)
+          return unless node.method?(:inquiry) && node.arguments.empty?
+          return unless (receiver = node.receiver)
+          return if !receiver.str_type? && !receiver.array_type?
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -129,10 +129,6 @@ module RuboCop
       # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Cop
-        extend TargetRailsVersion
-
-        minimum_target_rails_version 4.1
-
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
         NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to ' \
           'use `inverse_of: false`.'

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

@@ -35,6 +35,7 @@ module RuboCop
           (pair {(sym :rel) (str "rel")} (str _))
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless node.method?(:link_to)
 
@@ -42,11 +43,10 @@ module RuboCop
 
           option_nodes.map(&:children).each do |options|
             blank = options.find { |o| blank_target?(o) }
-            if blank && options.none? { |o| includes_noopener?(o) }
-              add_offense(blank)
-            end
+            add_offense(blank) if blank && options.none? { |o| includes_noopener?(o) }
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def autocorrect(node)
           lambda do |corrector|

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that mailer names end with `Mailer` suffix.
+      #
+      # Without the `Mailer` suffix it isn't immediately apparent what's a mailer
+      # and which views are related to the mailer.
+      #
+      # @example
+      #   # bad
+      #   class User < ActionMailer::Base
+      #   end
+      #
+      #   class User < ApplicationMailer
+      #   end
+      #
+      #   # good
+      #   class UserMailer < ActionMailer::Base
+      #   end
+      #
+      #   class UserMailer < ApplicationMailer
+      #   end
+      #
+      class MailerName < Cop
+        MSG = 'Mailer should end with `Mailer` suffix.'
+
+        def_node_matcher :mailer_base_class?, <<~PATTERN
+          {
+            (const (const nil? :ActionMailer) :Base)
+            (const nil? :ApplicationMailer)
+          }
+        PATTERN
+
+        def_node_matcher :class_definition?, <<~PATTERN
+          (class $(const _ !#mailer_suffix?) #mailer_base_class? ...)
+        PATTERN
+
+        def_node_matcher :class_new_definition?, <<~PATTERN
+          (send (const nil? :Class) :new #mailer_base_class?)
+        PATTERN
+
+        def on_class(node)
+          class_definition?(node) do |name_node|
+            add_offense(name_node)
+          end
+        end
+
+        def on_send(node)
+          return unless class_new_definition?(node)
+
+          casgn_parent = node.each_ancestor(:casgn).first
+          return unless casgn_parent
+
+          name = casgn_parent.children[1]
+          add_offense(casgn_parent, location: :name) unless mailer_suffix?(name)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.casgn_type?
+              name = node.children[1]
+              corrector.replace(node.loc.name, "#{name}Mailer")
+            else
+              name = node.children.last
+              corrector.replace(node.source_range, "#{name}Mailer")
+            end
+          end
+        end
+
+        private
+
+        def mailer_suffix?(mailer_name)
+          mailer_name.to_s.end_with?('Mailer')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where defining routes with `match`
+      # can be replaced with a specific HTTP method.
+      #
+      # Don't use `match` to define any routes unless there is a need to map multiple request types
+      # among [:get, :post, :patch, :put, :delete] to a single action using the `:via` option.
+      #
+      # @example
+      #   # bad
+      #   match ':controller/:action/:id'
+      #   match 'photos/:id', to: 'photos#show', via: :get
+      #
+      #   # good
+      #   get ':controller/:action/:id'
+      #   get 'photos/:id', to: 'photos#show'
+      #   match 'photos/:id', to: 'photos#show', via: [:get, :post]
+      #   match 'photos/:id', to: 'photos#show', via: :all
+      #
+      class MatchRoute < Cop
+        MSG = 'Use `%<http_method>s` instead of `match` to define a route.'
+        HTTP_METHODS = %i[get post put patch delete].freeze
+
+        def_node_matcher :match_method_call?, <<~PATTERN
+          (send nil? :match $_ $(hash ...) ?)
+        PATTERN
+
+        def on_send(node)
+          match_method_call?(node) do |path_node, options_node|
+            return unless within_routes?(node)
+
+            options_node = path_node.hash_type? ? path_node : options_node.first
+
+            if options_node.nil?
+              message = format(MSG, http_method: 'get')
+              add_offense(node, message: message)
+            else
+              via = extract_via(options_node)
+              if via.size == 1 && http_method?(via.first)
+                message = format(MSG, http_method: via.first)
+                add_offense(node, message: message)
+              end
+            end
+          end
+        end
+
+        def autocorrect(node)
+          match_method_call?(node) do |path_node, options_node|
+            options_node = options_node.first
+
+            lambda do |corrector|
+              corrector.replace(node, replacement(path_node, options_node))
+            end
+          end
+        end
+
+        private
+
+        def_node_matcher :routes_draw?, <<~PATTERN
+          (send (send _ :routes) :draw)
+        PATTERN
+
+        def within_routes?(node)
+          node.each_ancestor(:block).any? { |a| routes_draw?(a.send_node) }
+        end
+
+        def extract_via(node)
+          via_pair = via_pair(node)
+          return %i[get] unless via_pair
+
+          _, via = *via_pair
+
+          if via.basic_literal?
+            [via.value]
+          elsif via.array_type?
+            via.values.map(&:value)
+          else
+            []
+          end
+        end
+
+        def via_pair(node)
+          node.pairs.find { |p| p.key.value == :via }
+        end
+
+        def http_method?(method)
+          HTTP_METHODS.include?(method.to_sym)
+        end
+
+        def replacement(path_node, options_node)
+          if path_node.hash_type?
+            http_method, options = *http_method_and_options(path_node)
+            "#{http_method} #{options.map(&:source).join(', ')}"
+          elsif options_node.nil?
+            "get #{path_node.source}"
+          else
+            http_method, options = *http_method_and_options(options_node)
+
+            if options.any?
+              "#{http_method} #{path_node.source}, #{options.map(&:source).join(', ')}"
+            else
+              "#{http_method} #{path_node.source}"
+            end
+          end
+        end
+
+        def http_method_and_options(node)
+          via_pair = via_pair(node)
+          http_method = extract_via(node).first
+          rest_pairs = node.pairs - [via_pair]
+          [http_method, rest_pairs]
+        end
+      end
+    end
+  end
+end