rubocop 0.90.0 → 0.93.1

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,27 @@ 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
+          # FIXME: Workaround for pending status for `Layout/BeginEndAlignment` cop
+          #        When RuboCop 1.0 is released, please replace it with the following condition.
+          #
+          # config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+          #   config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          if config.for_all_cops['NewCops'] == 'enable' ||
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] &&
+             config.for_cop('Layout/BeginEndAlignment')['Enabled'] != 'pending'
+            config.for_cop('Layout/BeginEndAlignment')['EnforcedStyleAlignWith']
+          end
+        end
       end
     end
   end

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

@@ -36,8 +36,8 @@ module RuboCop
         MSG = 'Surrounding space %<type>s in default value assignment.'
 
         def on_optarg(node)
-          index = index_of_first_token(node)
-          arg, equals, value = processed_source.tokens[index, 3]
+          tokens = processed_source.tokens_within(node)
+          arg, equals, value = tokens.take(3)
           check_optarg(arg, equals, value)
         end
 
@@ -51,22 +51,13 @@ module RuboCop
              style == :no_space && no_surrounding_space
             correct_style_detected
           else
-            incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+            incorrect_style_detected(arg, value)
           end
         end
 
-        def incorrect_style_detected(arg, value, space_on_both_sides,
-                                     no_surrounding_space)
+        def incorrect_style_detected(arg, value)
           range = range_between(arg.end_pos, value.begin_pos)
 
-          if style == :space && no_surrounding_space ||
-             style == :no_space && space_on_both_sides
-            return unless opposite_style_detected
-          else
-            return unless unrecognized_style_detected
-          end
-
           add_offense(range) do |corrector|
             autocorrect(corrector, range)
           end

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

@@ -108,11 +108,11 @@ module RuboCop
         end
 
         def left_array_bracket(node)
-          tokens(node).find(&:left_array_bracket?)
+          processed_source.tokens_within(node).find(&:left_array_bracket?)
         end
 
         def right_array_bracket(node)
-          tokens(node).reverse.find(&:right_bracket?)
+          processed_source.tokens_within(node).reverse.find(&:right_bracket?)
         end
 
         def empty_config
@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def next_to_newline?(node, token)
-          tokens(node)[index_for(node, token) + 1].line != token.line
+          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
         end
 
         def end_has_own_line?(token)
@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def index_for(node, token)
-          tokens(node).index(token)
+          processed_source.tokens_within(node).index(token)
         end
 
         def line_and_column_for(token)
@@ -153,7 +153,7 @@ module RuboCop
         end
 
         def next_to_comment?(node, token)
-          tokens(node)[index_for(node, token) + 1].comment?
+          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
         end
 
         def compact_offenses(node, left, right, start_ok, end_ok)
@@ -184,9 +184,9 @@ module RuboCop
         def multi_dimensional_array?(node, token, side: :right)
           i = index_for(node, token)
           if side == :right
-            tokens(node)[i - 1].right_bracket?
+            processed_source.tokens_within(node)[i - 1].right_bracket?
           else
-            tokens(node)[i + 1].left_array_bracket?
+            processed_source.tokens_within(node)[i + 1].left_array_bracket?
           end
         end
 

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

@@ -206,8 +206,6 @@ module RuboCop
 
         def no_space(begin_pos, end_pos, msg)
           if style == :space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected
@@ -216,8 +214,6 @@ module RuboCop
 
         def space(begin_pos, end_pos, msg)
           if style == :no_space
-            return unless opposite_style_detected
-
             offense(begin_pos, end_pos, msg)
           else
             correct_style_detected

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

@@ -72,29 +72,15 @@ module RuboCop
         MSG = 'Space inside %<problem>s.'
 
         def on_hash(node)
-          tokens = processed_source.tokens
+          tokens = processed_source.tokens_within(node)
+          return unless tokens.first.left_brace? && tokens.last.right_curly_brace?
 
-          hash_literal_with_braces(node) do |begin_index, end_index|
-            check(tokens[begin_index], tokens[begin_index + 1])
-            return if begin_index == end_index - 1
-
-            check(tokens[end_index - 1], tokens[end_index])
-          end
+          check(tokens[0], tokens[1])
+          check(tokens[-2], tokens[-1]) if tokens.size > 2
         end
 
         private
 
-        def hash_literal_with_braces(node)
-          tokens = processed_source.tokens
-          begin_index = index_of_first_token(node)
-          return unless tokens[begin_index].left_brace?
-
-          end_index = index_of_last_token(node)
-          return unless tokens[end_index].right_curly_brace?
-
-          yield begin_index, end_index
-        end
-
         def check(token1, token2)
           # No offense if line break inside.
           return if token1.line < token2.line
@@ -126,12 +112,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,13 +61,12 @@ 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)
+          tokens = processed_source.tokens_within(node)
           left_token = left_ref_bracket(node, tokens)
           return unless left_token
 
@@ -99,15 +98,11 @@ module RuboCop
         end
 
         def reference_brackets(node)
-          tokens = tokens(node)
+          tokens = processed_source.tokens_within(node)
           left = left_ref_bracket(node, tokens)
           [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/layout/space_inside_string_interpolation.rb

@@ -54,8 +54,8 @@ module RuboCop
         end
 
         def delimiters(begin_node)
-          left = processed_source.tokens[index_of_first_token(begin_node)]
-          right = processed_source.tokens[index_of_last_token(begin_node)]
+          left = processed_source.first_token_of(begin_node)
+          right = processed_source.last_token_of(begin_node)
           [left, right]
         end
       end

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

@@ -15,6 +15,8 @@ module RuboCop
       #
       #   # good
       #   # With parentheses, there's no ambiguity.
+      #   some_method(a { |val| puts val })
+      #   # or (different meaning)
       #   some_method(a) { |val| puts val }
       #
       #   # good

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/ambiguous_regexp_literal.rb

@@ -47,7 +47,24 @@ module RuboCop
             regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
           end
 
-          node.parent
+          find_offense_node(node.parent, node)
+        end
+
+        def find_offense_node(node, regexp_receiver)
+          return node unless node.parent
+
+          if node.parent.send_type? || method_chain_to_regexp_receiver?(node, regexp_receiver)
+            node = find_offense_node(node.parent, regexp_receiver)
+          end
+
+          node
+        end
+
+        def method_chain_to_regexp_receiver?(node, regexp_receiver)
+          return false unless (parent = node.parent)
+          return false unless (parent_receiver = parent.receiver)
+
+          parent.parent && parent_receiver.receiver == regexp_receiver
         end
       end
     end

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/boolean_symbol.rb

@@ -32,6 +32,9 @@ module RuboCop
         def on_sym(node)
           return unless boolean_symbol?(node)
 
+          parent = node.parent
+          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+
           add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
             autocorrect(corrector, node)
           end

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

@@ -0,0 +1,74 @@
+# 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.
+      #
+      # If you are trying to define that constant once, define it outside of
+      # the block instead, or use a variable or method if defining the constant
+      # in the outer scope would be problematic.
+      #
+      # For meta-programming, use `const_set`.
+      #
+      # @example
+      #   # bad
+      #   task :lint do
+      #     FILES_TO_LINT = Dir['lib/*.rb']
+      #   end
+      #
+      #   # bad
+      #   describe 'making a request' do
+      #     class TestRequest; end
+      #   end
+      #
+      #   # bad
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       LIST = []
+      #     end
+      #   end
+      #
+      #   # good
+      #   task :lint do
+      #     files_to_lint = Dir['lib/*.rb']
+      #   end
+      #
+      #   # good
+      #   describe 'making a request' do
+      #     let(:test_request) { Class.new }
+      #     # see also `stub_const` for RSpec
+      #   end
+      #
+      #   # good
+      #   module M
+      #     extend ActiveSupport::Concern
+      #     included do
+      #       const_set(:LIST, [])
+      #     end
+      #   end
+      class ConstantDefinitionInBlock < Base
+        MSG = 'Do not define constants this way 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))