rubocop-rails 2.6.0 → 2.7.0

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

@@ -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/file_path.rb

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source =~ %r{/}
+          node.str_type? && node.source.match?(%r{/})
         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/inquiry.rb

@@ -0,0 +1,34 @@
+# 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)
+          add_offense(node, location: :selector) if node.method?(:inquiry) && node.arguments.empty?
+        end
+      end
+    end
+  end
+end

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)
 
@@ -45,6 +46,7 @@ module RuboCop
             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,117 @@
+# 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)
+          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

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `collection.exclude?(obj)`
+      # over `!collection.include?(obj)`.
+      #
+      # @example
+      #   # bad
+      #   !array.include?(2)
+      #   !hash.include?(:key)
+      #
+      #   # good
+      #   array.exclude?(2)
+      #   hash.exclude?(:key)
+      #
+      class NegateInclude < Cop
+        MSG = 'Use `.exclude?` and remove the negation part.'
+
+        def_node_matcher :negate_include_call?, <<~PATTERN
+          (send (send $_ :include? $_) :!)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if negate_include_call?(node)
+        end
+
+        def autocorrect(node)
+          negate_include_call?(node) do |receiver, obj|
+            lambda do |corrector|
+              corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,20 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the use `pick` over `pluck(...).first`.
+      # This cop enforces the use of `pick` over `pluck(...).first`.
+      #
+      # Using `pluck` followed by `first` creates an intermediate array, which
+      # `pick` avoids. When called on an Active Record relation, `pick` adds a
+      # limit to the query so that only one value is fetched from the database.
       #
       # @example
       #   # bad
       #   Model.pluck(:a).first
-      #   Model.pluck(:a, :b).first
+      #   [{ a: :b, c: :d }].pluck(:a, :b).first
       #
       #   # good
       #   Model.pick(:a)
-      #   Model.pick(:a, :b)
+      #   [{ a: :b, c: :d }].pick(:a, :b)
       class Pick < Cop
         extend TargetRailsVersion
 

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `pluck` over `map`.
+      #
+      # `pluck` can be used instead of `map` to extract a single key from each
+      # element in an enumerable. When called on an Active Record relation, it
+      # results in a more efficient query that only selects the necessary key.
+      #
+      # @example
+      #   # bad
+      #   Post.published.map { |post| post[:title] }
+      #   [{ a: :b, c: :d }].collect { |el| el[:a] }
+      #
+      #   # good
+      #   Post.published.pluck(:title)
+      #   [{ a: :b, c: :d }].pluck(:a)
+      class Pluck < Cop
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `pluck(:%<value>s)` over `%<method>s { |%<argument>s| %<element>s[:%<value>s] }`.'
+
+        minimum_target_rails_version 5.0
+
+        def_node_matcher :pluck_candidate?, <<~PATTERN
+          (block (send _ ${:map :collect}) (args (arg $_argument)) (send (lvar $_element) :[] (sym $_value)))
+        PATTERN
+
+        def on_block(node)
+          pluck_candidate?(node) do |method, argument, element, value|
+            next unless argument == element
+
+            add_offense(node, location: offense_range(node), message: message(method, argument, element, value))
+          end
+        end
+
+        def autocorrect(node)
+          _method, _argument, _element, value = pluck_candidate?(node)
+
+          lambda do |corrector|
+            corrector.replace(offense_range(node), "pluck(:#{value})")
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.send_node.loc.selector.join(node.loc.end)
+        end
+
+        def message(method, argument, element, value)
+          format(MSG, method: method, argument: argument, element: element, value: value)
+        end
+      end
+    end
+  end
+end