rubocop 0.90.0 → 0.91.0

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -23,6 +23,7 @@ module RuboCop
       #   end
       class RescueEnsureAlignment < Base
         include RangeHelp
+        include EndKeywordAlignment
         extend AutoCorrector
 
         MSG = '`%<kw_loc>s` at %<kw_loc_line>d, %<kw_loc_column>d is not ' \
@@ -59,7 +60,7 @@ module RuboCop
           alignment_node = alignment_node(node)
           return if alignment_node.nil?
 
-          alignment_loc = alignment_node.loc.expression
+          alignment_loc = alignment_location(alignment_node)
           kw_loc        = node.loc.keyword
 
           return if alignment_loc.column == kw_loc.column || alignment_loc.line == kw_loc.line
@@ -67,16 +68,16 @@ module RuboCop
           add_offense(
             kw_loc, message: format_message(alignment_node, alignment_loc, kw_loc)
           ) do |corrector|
-            autocorrect(corrector, node, alignment_node)
+            autocorrect(corrector, node, alignment_loc)
           end
         end
 
-        def autocorrect(corrector, node, alignment_node)
+        def autocorrect(corrector, node, alignment_location)
           whitespace = whitespace_range(node)
           # Some inline node is sitting before current node.
           return nil unless whitespace.source.strip.empty?
 
-          new_column = alignment_node.loc.column
+          new_column = alignment_location.column
 
           corrector.replace(whitespace, ' ' * new_column)
         end
@@ -180,6 +181,18 @@ module RuboCop
 
           false
         end
+
+        def alignment_location(alignment_node)
+          if begin_end_alignment_style == 'start_of_line'
+            start_line_range(alignment_node)
+          else
+            alignment_node.loc.expression
+          end
+        end
+
+        def begin_end_alignment_style
+          config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -126,12 +126,11 @@ module RuboCop
 
         def incorrect_style_detected(token1, token2,
                                      expect_space, is_empty_braces)
+          return unless ambiguous_or_unexpected_style_detected(style, token1.text == token2.text)
+
           brace = (token1.text == '{' ? token1 : token2).pos
           range = expect_space ? brace : space_range(brace)
 
-          style = expect_space ? :no_space : :space
-          return unless ambiguous_or_unexpected_style_detected(style, token1.text == token2.text)
-
           add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
             autocorrect(corrector, range)
           end

data/lib/rubocop/cop/layout/space_inside_reference_brackets.rb

@@ -61,11 +61,10 @@ module RuboCop
         MSG = '%<command>s space inside reference brackets.'
         EMPTY_MSG = '%<command>s space inside empty reference brackets.'
 
-        BRACKET_METHODS = %i[[] []=].freeze
+        RESTRICT_ON_SEND = %i[[] []=].freeze
 
         def on_send(node)
           return if node.multiline?
-          return unless bracket_method?(node)
 
           tokens = tokens(node)
           left_token = left_ref_bracket(node, tokens)
@@ -104,10 +103,6 @@ module RuboCop
           [left, closing_bracket(tokens, left)]
         end
 
-        def bracket_method?(node)
-          BRACKET_METHODS.include?(node.method_name)
-        end
-
         def left_ref_bracket(node, tokens)
           current_token = tokens.reverse.find(&:left_ref_bracket?)
           previous_token = previous_token(current_token)

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -43,6 +43,8 @@ module RuboCop
             next unless diagnostic.reason == :ambiguous_prefix
 
             offense_node = find_offense_node_by(diagnostic)
+            next unless offense_node
+
             message = message(diagnostic)
 
             add_offense(

data/lib/rubocop/cop/lint/big_decimal_new.rb

@@ -19,6 +19,7 @@ module RuboCop
 
         MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
               'Use `%<double_colon>sBigDecimal()` instead.'
+        RESTRICT_ON_SEND = %i[new].freeze
 
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
@@ -26,8 +27,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:new)
-
           big_decimal_new(node) do |captured_value|
             double_colon = captured_value ? '::' : ''
             message = format(MSG, double_colon: double_colon)

data/lib/rubocop/cop/lint/constant_definition_in_block.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Do not define constants within a block, since the block's scope does not
+      # isolate or namespace the constant in any way.
+      #
+      # Define the constant outside of the block instead, or use a variable or
+      # method if defining the constant in the outer scope would be problematic.
+      #
+      # @example
+      #   # bad
+      #   task :lint do
+      #     FILES_TO_LINT = Dir['lib/*.rb']
+      #   end
+      #
+      #   # bad
+      #   describe 'making a request' do
+      #     class TestRequest; end
+      #   end
+      #
+      #   # good
+      #   task :lint do
+      #     files_to_lint = Dir['lib/*.rb']
+      #   end
+      #
+      #   # good
+      #   describe 'making a request' do
+      #     let(:test_request) { Class.new }
+      #   end
+      class ConstantDefinitionInBlock < Base
+        MSG = 'Do not define constants within a block.'
+
+        def_node_matcher :constant_assigned_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+        PATTERN
+
+        def_node_matcher :module_defined_in_block?, <<~PATTERN
+          ({^block_type? [^begin_type? ^^block_type?]} ...)
+        PATTERN
+
+        def on_casgn(node)
+          add_offense(node) if constant_assigned_in_block?(node)
+        end
+
+        def on_class(node)
+          add_offense(node) if module_defined_in_block?(node)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/debugger.rb

@@ -35,10 +35,10 @@ module RuboCop
       class Debugger < Base
         MSG = 'Remove debugger entry point `%<source>s`.'
 
-        DEBUGGER_METHODS = %i[
+        RESTRICT_ON_SEND = %i[
           debugger byebug remote_byebug pry remote_pry pry_remote console rescue
           save_and_open_page save_and_open_screenshot save_screenshot irb
-        ].to_set.freeze
+        ].freeze
 
         def_node_matcher :kernel?, <<~PATTERN
           {
@@ -62,7 +62,6 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless DEBUGGER_METHODS.include?(node.method_name)
           return unless debugger_call?(node) || binding_irb?(node)
 
           add_offense(node)

data/lib/rubocop/cop/lint/deprecated_class_methods.rb

@@ -62,11 +62,9 @@ module RuboCop
                                     replacement: :block_given?)
         ].freeze
 
-        DEPRECATED_METHODS = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
+        RESTRICT_ON_SEND = DEPRECATED_METHODS_OBJECT.map(&:deprecated_method).freeze
 
         def on_send(node)
-          return unless DEPRECATED_METHODS.include?(node.method_name)
-
           check(node) do |data|
             message = format(MSG, current: deprecated_method(data),
                                   prefer: replacement_method(data))

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -53,8 +53,8 @@ module RuboCop
         MSG = 'Method `%<method>s` is defined at both %<defined>s and ' \
               '%<current>s.'
 
-        METHOD_DEF_METHODS = %i[alias_method attr_reader attr_writer
-                                attr_accessor attr].to_set.freeze
+        RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer
+                              attr_accessor attr].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -100,8 +100,6 @@ module RuboCop
 
         def_node_matcher :sym_name, '(sym $_name)'
         def on_send(node)
-          return unless METHOD_DEF_METHODS.include?(node.method_name)
-
           if (name = alias_method?(node))
             return if node.ancestors.any?(&:if_type?)
             return if possible_dsl?(node)

data/lib/rubocop/cop/lint/duplicate_require.rb

@@ -15,9 +15,14 @@ module RuboCop
       #   require 'foo'
       #   require 'bar'
       #
+      #   # good
+      #   require 'foo'
+      #   require_relative 'foo'
+      #
       class DuplicateRequire < Base
         MSG = 'Duplicate `%<method>s` detected.'
         REQUIRE_METHODS = %i[require require_relative].freeze
+        RESTRICT_ON_SEND = REQUIRE_METHODS
 
         def_node_matcher :require_call?, <<~PATTERN
           (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
@@ -30,8 +35,8 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless REQUIRE_METHODS.include?(node.method_name) && require_call?(node)
-          return if @required[node.parent].add?(node.first_argument)
+          return unless require_call?(node)
+          return if @required[node.parent].add?("#{node.method_name}#{node.first_argument}")
 
           add_offense(node, message: format(MSG, method: node.method_name))
         end

data/lib/rubocop/cop/lint/each_with_object_argument.rb

@@ -23,6 +23,7 @@ module RuboCop
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Base
         MSG = 'The argument to each_with_object cannot be immutable.'
+        RESTRICT_ON_SEND = %i[each_with_object].freeze
 
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)

data/lib/rubocop/cop/lint/empty_file.rb

@@ -26,10 +26,7 @@ module RuboCop
         MSG = 'Empty file detected.'
 
         def on_new_investigation
-          return unless offending?
-
-          range = source_range(processed_source.buffer, 1, 0)
-          add_offense(range)
+          add_global_offense(MSG) if offending?
         end
 
         private

data/lib/rubocop/cop/lint/erb_new_arguments.rb

@@ -78,6 +78,8 @@ module RuboCop
           '`ERB.new(str, eoutvar: %<arg_value>s)` instead.'
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :erb_new_with_non_keyword_arguments, <<~PATTERN
           (send
             (const {nil? cbase} :ERB) :new $...)

data/lib/rubocop/cop/lint/float_comparison.rb

@@ -35,9 +35,9 @@ module RuboCop
         FLOAT_RETURNING_METHODS = %i[to_f Float fdiv].freeze
         FLOAT_INSTANCE_METHODS = %i[@- abs magnitude modulo next_float prev_float quo].to_set.freeze
 
-        def on_send(node)
-          return unless EQUALITY_METHODS.include?(node.method_name)
+        RESTRICT_ON_SEND = EQUALITY_METHODS
 
+        def on_send(node)
           lhs, _method, rhs = *node
           add_offense(node) if float?(lhs) || float?(rhs)
         end

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -44,10 +44,10 @@ module RuboCop
         KERNEL = 'Kernel'
         SHOVEL = '<<'
         STRING_TYPES = %i[str dstr].freeze
-        FORMAT_METHODS = %i[format sprintf %].freeze
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def on_send(node)
-          return unless FORMAT_METHODS.include?(node.method_name) && format_string?(node)
+          return unless format_string?(node)
 
           if invalid_format_string?(node)
             add_offense(node.loc.selector, message: MSG_INVALID)

data/lib/rubocop/cop/lint/identity_comparison.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      #
+      # Prefer `equal?` over `==` when comparing `object_id`.
+      #
+      # `Object#equal?` is provided to compare objects for identity, and in contrast
+      # `Object#==` is provided for the purpose of doing value comparison.
+      #
+      # @example
+      #   # bad
+      #   foo.object_id == bar.object_id
+      #
+      #   # good
+      #   foo.equal?(bar)
+      #
+      class IdentityComparison < Base
+        extend AutoCorrector
+
+        MSG = 'Use `equal?` instead `==` when comparing `object_id`.'
+        RESTRICT_ON_SEND = %i[==].freeze
+
+        def on_send(node)
+          return unless compare_between_object_id_by_double_equal?(node)
+
+          add_offense(node) do |corrector|
+            receiver = node.receiver.receiver.source
+            argument = node.first_argument.receiver.source
+            replacement = "#{receiver}.equal?(#{argument})"
+
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def compare_between_object_id_by_double_equal?(node)
+          object_id_method?(node.receiver) && object_id_method?(node.first_argument)
+        end
+
+        def object_id_method?(node)
+          node.send_type? && node.method?(:object_id)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/inherit_exception.rb

@@ -56,6 +56,8 @@ module RuboCop
           SystemExit
         ].freeze
 
+        RESTRICT_ON_SEND = %i[new].freeze
+
         def_node_matcher :class_new_call?, <<~PATTERN
           (send
             (const {cbase nil?} :Class) :new
@@ -74,8 +76,6 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.method?(:new)
-
           constant = class_new_call?(node)
           return unless constant && illegal_class_name?(constant)
 

data/lib/rubocop/cop/lint/multiple_comparison.rb

@@ -25,9 +25,11 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use the `&&` operator to compare multiple values.'
+        COMPARISON_METHODS = %i[< > <= >=].freeze
+        RESTRICT_ON_SEND = COMPARISON_METHODS
 
         def_node_matcher :multiple_compare?, <<~PATTERN
-          (send (send _ {:< :> :<= :>=} $_) {:< :> :<= :>=} _)
+          (send (send _ {:< :> :<= :>=} $_) {:#{COMPARISON_METHODS.join(' :')}} _)
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/lint/number_conversion.rb

@@ -32,6 +32,7 @@ module RuboCop
               'class parsing, instead of using '\
               '%<number_object>s.%<to_method>s, use stricter '\
               '%<corrected_method>s.'
+        RESTRICT_ON_SEND = CONVERSION_METHOD_CLASS_MAPPING.keys.freeze
 
         def_node_matcher :to_method, <<~PATTERN
           (send $_ ${:to_i :to_f :to_c})

data/lib/rubocop/cop/lint/out_of_range_regexp_ref.rb

@@ -25,6 +25,7 @@ module RuboCop
         REGEXP_ARGUMENT_METHODS = %i[=~ match grep gsub gsub! sub sub! [] slice slice! index rindex
                                      scan partition rpartition start_with? end_with?].to_set.freeze
         REGEXP_CAPTURE_METHODS = (REGEXP_RECEIVER_METHODS + REGEXP_ARGUMENT_METHODS).freeze
+        RESTRICT_ON_SEND = REGEXP_CAPTURE_METHODS
 
         def on_new_investigation
           @valid_ref = 0
@@ -35,8 +36,6 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless REGEXP_CAPTURE_METHODS.include?(node.method_name)
-
           @valid_ref = nil
 
           if node.receiver&.regexp_type?

data/lib/rubocop/cop/lint/raise_exception.rb

@@ -31,6 +31,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `StandardError` over `Exception`.'
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         def_node_matcher :exception?, <<~PATTERN
           (send nil? {:raise :fail} $(const ${cbase nil?} :Exception) ... )

data/lib/rubocop/cop/lint/rand_one.rb

@@ -23,13 +23,14 @@ module RuboCop
       class RandOne < Base
         MSG = '`%<method>s` always returns `0`. ' \
               'Perhaps you meant `rand(2)` or `rand`?'
+        RESTRICT_ON_SEND = %i[rand].freeze
 
         def_node_matcher :rand_one?, <<~PATTERN
           (send {(const {nil? cbase} :Kernel) nil?} :rand {(int {-1 1}) (float {-1.0 1.0})})
         PATTERN
 
         def on_send(node)
-          return unless node.method?(:rand) && rand_one?(node)
+          return unless rand_one?(node)
 
           add_offense(node)
         end