rubocop 0.62.0 → 0.63.0

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

@@ -21,11 +21,18 @@ module RuboCop
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
-        # TODO: Whether frozen string literals will be the default in Ruby 3.0
-        # or not is still unclear as of February 2018.
-        # It may be necessary to change this code in the future.
+        # TODO: Ruby officially abandon making frozen string literals default
+        # for Ruby 3.0.
+        # https://bugs.ruby-lang.org/issues/11473#note-53
+        # Whether frozen string literals will be the default after Ruby 3.0
+        # or not is still unclear as of January 2019.
+        # It may be necessary to add this code in the future.
+        #
+        #   return true if ruby_version >= 3.1
+        #
+        # And the above `ruby_version >= 3.1` is undecidedd whether it will be
+        # Ruby 3.1, 3.2, 4.0 or others.
         # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
-        return true if ruby_version >= 3.0
         return false unless ruby_version >= 2.3
 
         leading_comment_lines.any? do |line|

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

@@ -2,13 +2,19 @@
 
 module RuboCop
   module Cop
-    # This module provides a list of methods that are either in the NilClass,
-    # or in the cop's configuration parameter Whitelist.
+    # This module provides a list of methods that are:
+    # 1. In the NilClass by default
+    # 2. Added to NilClass by explicitly requiring any standard libraries
+    # 3. Cop's configuration parameter Whitelist.
     module NilMethods
       private
 
       def nil_methods
-        nil.methods + whitelist
+        nil.methods + other_stdlib_methods + whitelist
+      end
+
+      def other_stdlib_methods
+        [:to_d]
       end
 
       def whitelist

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

@@ -17,9 +17,9 @@ module RuboCop
       end
 
       def check(node, items, kind, begin_pos, end_pos)
-        after_last_item = range_between(begin_pos, end_pos)
+        return if heredoc?(items.last)
 
-        return if heredoc?(after_last_item.source)
+        after_last_item = range_between(begin_pos, end_pos)
 
         comma_offset = after_last_item.source =~ /,/
 
@@ -76,10 +76,6 @@ module RuboCop
         end
       end
 
-      def heredoc?(source_after_last_item)
-        source_after_last_item !~ /^\s*#/ && source_after_last_item =~ /\w/
-      end
-
       # Returns true if the node has round/square/curly brackets.
       def brackets?(node)
         node.loc.end
@@ -170,6 +166,45 @@ module RuboCop
       def avoid_autocorrect?(_nodes)
         false
       end
+
+      def heredoc?(node)
+        return false unless node.is_a?(RuboCop::AST::Node)
+        return true if node.loc.respond_to?(:heredoc_body)
+
+        return heredoc_send?(node) if node.send_type?
+
+        # handle hash values
+        #
+        #   some_method({
+        #     'auth' => <<-SOURCE
+        #       ...
+        #     SOURCE
+        #   })
+        if node.pair_type? || node.hash_type?
+          return heredoc?(node.children.last)
+        end
+
+        false
+      end
+
+      def heredoc_send?(node)
+        # handle heredocs with methods
+        #
+        #   some_method(<<-CODE.strip.chomp)
+        #     ...
+        #   CODE
+        return heredoc?(node.children.first) if node.children.size == 2
+        # handle nested methods
+        #
+        #   some_method(
+        #     another_method(<<-CODE.strip.chomp)
+        #       ...
+        #     CODE
+        #   )
+        return heredoc?(node.children.last) if node.children.size > 2
+
+        false
+      end
     end
   end
 end

data/lib/rubocop/cop/naming/constant_name.rb

@@ -54,13 +54,22 @@ module RuboCop
         def allowed_assignment?(value)
           value && %i[block const casgn].include?(value.type) ||
             allowed_method_call_on_rhs?(value) ||
-            class_or_struct_return_method?(value)
+            class_or_struct_return_method?(value) ||
+            allowed_conditional_expression_on_rhs?(value)
         end
 
         def allowed_method_call_on_rhs?(node)
           node && node.send_type? &&
             (node.receiver.nil? || !node.receiver.literal?)
         end
+
+        def allowed_conditional_expression_on_rhs?(node)
+          node && node.if_type? && contains_contant?(node)
+        end
+
+        def contains_contant?(node)
+          node.branches.any?(&:const_type?)
+        end
       end
     end
   end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -61,7 +61,7 @@ module RuboCop
         private
 
         def allowed_method_name?(method_name, prefix)
-          !method_name.start_with?(prefix) ||
+          !method_name.match(/^#{prefix}[^0-9]/) ||
             method_name == expected_name(method_name, prefix) ||
             method_name.end_with?('=') ||
             predicate_whitelist.include?(method_name)

data/lib/rubocop/cop/performance/range_include.rb

@@ -9,6 +9,9 @@ module RuboCop
       # end points of the `Range`. In a great majority of cases, this is what
       # is wanted.
       #
+      # This cop is `Safe: false` by default because `Range#include?` and
+      # `Range#cover?` are not equivalent behaviour.
+      #
       # @example
       #   # bad
       #   ('a'..'z').include?('b') # => true

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for belongs_to associations where we control whether the
+      # association is required via the deprecated `required` option instead.
+      #
+      # Since Rails 5, belongs_to associations are required by default and this
+      # can be controlled through the use of `optional: true`.
+      #
+      # From the release notes:
+      #
+      #     belongs_to will now trigger a validation error by default if the
+      #     association is not present. You can turn this off on a
+      #     per-association basis with optional: true. Also deprecate required
+      #     option in favor of optional for belongs_to. (Pull Request)
+      #
+      # In the case that the developer is doing `required: false`, we
+      # definitely want to autocorrect to `optional: true`.
+      #
+      # However, without knowing whether they've set overriden the default
+      # value of `config.active_record.belongs_to_required_by_default`, we
+      # can't say whether it's safe to remove `required: true` or whether we
+      # should replace it with `optional: false` (or, similarly, remove a
+      # superfluous `optional: false`). Therefore, in the cases we're using
+      # `required: true`, we'll simply invert it to `optional: false` and the
+      # user can remove depending on their defaults.
+      #
+      # @example
+      #   # bad
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, required: false
+      #   end
+      #
+      #   # good
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, optional: true
+      #   end
+      #
+      #   # bad
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, required: true
+      #   end
+      #
+      #   # good
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, optional: false
+      #   end
+      #
+      # @see https://guides.rubyonrails.org/5_0_release_notes.html
+      # @see https://github.com/rails/rails/pull/18937
+      class BelongsTo < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        SUPERFLOUS_REQUIRE_FALSE_MSG =
+          'You specified `required: false`, in Rails > 5.0 the required ' \
+          'option is deprecated and you want to use `optional: true`.'.freeze
+
+        SUPERFLOUS_REQUIRE_TRUE_MSG =
+          'You specified `required: true`, in Rails > 5.0 the required ' \
+          'option is deprecated and you want to use `optional: false`. ' \
+          'In most configurations, this is the default and you can omit ' \
+          'this option altogether'.freeze
+
+        def_node_matcher :match_belongs_to_with_options, <<-PATTERN
+          (send $_ :belongs_to _ (hash $...))
+        PATTERN
+
+        def_node_matcher :match_required_false?, <<-PATTERN
+          (pair (sym :required) false)
+        PATTERN
+
+        def_node_matcher :match_required_true?, <<-PATTERN
+          (pair (sym :required) true)
+        PATTERN
+
+        def on_send(node)
+          opt = extract_required_option(node)
+          return unless opt
+          return unless match_required_true?(opt) || match_required_false?(opt)
+
+          message =
+            if match_required_true?(opt)
+              SUPERFLOUS_REQUIRE_TRUE_MSG
+            elsif match_required_false?(opt)
+              SUPERFLOUS_REQUIRE_FALSE_MSG
+            end
+
+          add_offense(node, message: message, location: :selector)
+        end
+
+        def autocorrect(node)
+          opt = extract_required_option(node)
+          return unless opt
+
+          lambda do |corrector|
+            if match_required_true?(opt)
+              corrector.replace(opt.loc.expression, 'optional: false')
+            elsif match_required_false?(opt)
+              corrector.replace(opt.loc.expression, 'optional: true')
+            end
+          end
+        end
+
+        def extract_required_option(node)
+          _, opts = match_belongs_to_with_options(node)
+          return unless opts
+
+          opts.find do |opt|
+            match_required_true?(opt) ||
+              match_required_false?(opt)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that `if` and `only` (or `except`) are not used together
+      # as options of `skip_*` action filter.
+      #
+      # The `if` option will be ignored when `if` and `only` are used together.
+      # Similarly, the `except` option will be ignored when `if` and `except`
+      # are used together.
+      #
+      # @example
+      #   # bad
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       only: :show, if: :trusted_origin?
+      #   end
+      #
+      #   # good
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       if: -> { trusted_origin? && action_name == "show" }
+      #   end
+      #
+      # @example
+      #   # bad
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       except: :admin, if: :trusted_origin?
+      #   end
+      #
+      #   # good
+      #   class MyPageController < ApplicationController
+      #     skip_before_action :login_required,
+      #       if: -> { trusted_origin? && action_name != "admin" }
+      #   end
+      #
+      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
+      class IgnoredSkipActionFilterOption < Cop
+        MSG = <<-MSG.strip_indent.chomp.freeze
+          `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
+        MSG
+
+        FILTERS = %w[
+          :skip_after_action
+          :skip_around_action
+          :skip_before_action
+          :skip_action_callback
+        ].freeze
+
+        def_node_matcher :filter_options, <<-PATTERN
+          (send
+            nil?
+            {#{FILTERS.join(' ')}}
+            _
+            $_)
+        PATTERN
+
+        def on_send(node)
+          options = filter_options(node)
+          return unless options
+          return unless options.hash_type?
+
+          options = options_hash(options)
+
+          if if_and_only?(options)
+            add_offense(options[:if],
+                        message: format(MSG, prefer: :only, ignore: :if))
+          elsif if_and_except?(options)
+            add_offense(options[:except],
+                        message: format(MSG, prefer: :if, ignore: :except))
+          end
+        end
+
+        private
+
+        def options_hash(options)
+          options.pairs
+                 .select { |pair| pair.key.sym_type? }
+                 .map { |pair| [pair.key.value, pair] }.to_h
+        end
+
+        def if_and_only?(options)
+          options.key?(:if) && options.key?(:only)
+        end
+
+        def if_and_except?(options)
+          options.key?(:if) && options.key?(:except)
+        end
+      end
+    end
+  end
+end

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

@@ -38,9 +38,8 @@ module RuboCop
       #   # good
       #   class Blog < ApplicationRecord
       #     has_many(:posts,
-      #       -> { order(published_at: :desc) },
-      #       inverse_of: :blog
-      #     )
+      #              -> { order(published_at: :desc) },
+      #              inverse_of: :blog)
       #   end
       #
       #   class Post < ApplicationRecord
@@ -62,9 +61,8 @@ module RuboCop
       #   # When you don't want to use the inverse association.
       #   class Blog < ApplicationRecord
       #     has_many(:posts,
-      #       -> { order(published_at: :desc) },
-      #       inverse_of: false
-      #     )
+      #              -> { order(published_at: :desc) },
+      #              inverse_of: false)
       #   end
       #
       # @example

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

@@ -25,6 +25,10 @@ module RuboCop
           (pair {(sym :rel) (str "rel")} (str #contains_noopener?))
         PATTERN
 
+        def_node_matcher :rel_node?, <<-PATTERN
+          (pair {(sym :rel) (str "rel")} (str _))
+        PATTERN
+
         def on_send(node)
           return unless node.method?(:link_to)
 
@@ -38,8 +42,41 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            send_node = node.parent.parent
+
+            option_nodes = send_node.each_child_node(:hash)
+            rel_node = nil
+            option_nodes.map(&:children).each do |options|
+              rel_node ||= options.find { |o| rel_node?(o) }
+            end
+
+            if rel_node
+              append_to_rel(rel_node, corrector)
+            else
+              add_rel(send_node, node, corrector)
+            end
+          end
+        end
+
         private
 
+        def append_to_rel(rel_node, corrector)
+          existing_rel = rel_node.children.last.value
+          str_range = rel_node.children.last.loc.expression.adjust(
+            begin_pos: 1,
+            end_pos: -1
+          )
+          corrector.replace(str_range, "#{existing_rel} noopener")
+        end
+
+        def add_rel(send_node, offence_node, corrector)
+          quote_style = offence_node.children.last.source[0]
+          new_rel_exp = ", rel: #{quote_style}noopener#{quote_style}"
+          corrector.insert_after(send_node.loc.expression, new_rel_exp)
+        end
+
         def contains_noopener?(str)
           return false unless str