rubocop 0.42.0 → 0.43.0

data/lib/rubocop/cop/style/space_around_block_parameters.rb

@@ -92,8 +92,7 @@ module RuboCop
         def check_no_space(space_begin_pos, space_end_pos, msg)
           return if space_begin_pos >= space_end_pos
 
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            space_begin_pos, space_end_pos)
+          range = range_between(space_begin_pos, space_end_pos)
           add_offense(range, range, "#{msg} block parameter detected.")
         end
 

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

@@ -33,9 +33,7 @@ module RuboCop
 
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
-          range = Parser::Source::Range.new(processed_source.buffer,
-                                            arg.pos.end_pos,
-                                            value.pos.begin_pos)
+          range = range_between(arg.pos.end_pos, value.pos.begin_pos)
           add_offense(range, range) do
             if style == :space && no_surrounding_space ||
                style == :no_space && space_on_both_sides

data/lib/rubocop/cop/style/space_around_operators.rb

@@ -19,6 +19,7 @@ module RuboCop
                     !any_pairs_on_the_same_line?(node.parent)
 
           _, right = *node
+
           check_operator(node.loc.operator, right.source_range)
         end
 
@@ -31,10 +32,10 @@ module RuboCop
         end
 
         def on_resbody(node)
-          if node.loc.assoc
-            _, variable, = *node
-            check_operator(node.loc.assoc, variable.source_range)
-          end
+          return unless node.loc.assoc
+          _, variable, = *node
+
+          check_operator(node.loc.assoc, variable.source_range)
         end
 
         def on_send(node)
@@ -88,20 +89,24 @@ module RuboCop
           with_space = range_with_surrounding_space(op)
           return if with_space.source.start_with?("\n")
 
+          offense(op, with_space, right_operand) do |msg|
+            add_offense(with_space, op, msg)
+          end
+        end
+
+        def offense(op, with_space, right_operand)
+          msg = offense_message(op, with_space, right_operand)
+          yield msg if msg
+        end
+
+        def offense_message(op, with_space, right_operand)
           if op.is?('**')
-            unless with_space.is?('**')
-              add_offense(with_space, op,
-                          'Space around operator `**` detected.')
-            end
+            'Space around operator `**` detected.' unless with_space.is?('**')
           elsif with_space.source !~ /^\s.*\s$/
-            add_offense(with_space, op, 'Surrounding space missing for ' \
-                                        "operator `#{op.source}`.")
-          elsif excess_leading_space?(op, with_space)
-            add_offense(with_space, op, "Operator `#{op.source}` should be " \
-                                        'surrounded by a single space.')
-          elsif excess_trailing_space?(right_operand, with_space)
-            add_offense(with_space, op, "Operator `#{op.source}` should be " \
-                                        'surrounded by a single space.')
+            "Surrounding space missing for operator `#{op.source}`."
+          elsif excess_leading_space?(op, with_space) ||
+                excess_trailing_space?(right_operand, with_space)
+            "Operator `#{op.source}` should be surrounded by a single space."
           end
         end
 

data/lib/rubocop/cop/style/space_before_block_braces.rb

@@ -12,15 +12,6 @@ module RuboCop
         def on_block(node)
           return if node.loc.begin.is?('do') # No braces.
 
-          # If braces are on separate lines, and the BlockDelimiters cop is
-          # enabled, those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             block_length(node) > 0
-            return
-          end
-
           left_brace = node.loc.begin
           space_plus_brace = range_with_surrounding_space(left_brace)
           used_style =
@@ -43,9 +34,8 @@ module RuboCop
         end
 
         def space_detected(left_brace, space_plus_brace)
-          space = Parser::Source::Range.new(left_brace.source_buffer,
-                                            space_plus_brace.begin_pos,
-                                            left_brace.begin_pos)
+          space = range_between(space_plus_brace.begin_pos,
+                                left_brace.begin_pos)
           add_offense(space, space, 'Space detected to the left of {.') do
             opposite_style_detected
           end

data/lib/rubocop/cop/style/space_before_first_arg.rb

@@ -29,9 +29,7 @@ module RuboCop
           _receiver, _method_name, *args = *node
           arg1 = args.first.source_range
           arg1_with_space = range_with_surrounding_space(arg1, :left)
-          space = Parser::Source::Range.new(arg1.source_buffer,
-                                            arg1_with_space.begin_pos,
-                                            arg1.begin_pos)
+          space = range_between(arg1_with_space.begin_pos, arg1.begin_pos)
           add_offense(space, space) if space.length > 1
         end
 

data/lib/rubocop/cop/style/space_inside_array_percent_literal.rb

@@ -21,7 +21,7 @@ module RuboCop
           /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/
 
         def on_array(node)
-          process(node, *%w(%i %I %w %W))
+          process(node, '%i', '%I', '%w', '%W')
         end
 
         def on_percent_literal(node)

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

@@ -15,15 +15,6 @@ module RuboCop
         def on_block(node)
           return if node.loc.begin.is?('do') # No braces.
 
-          # If braces are on separate lines, and the BlockDelimiters cop is
-          # enabled, those braces will be changed to do..end by the user or by
-          # auto-correct, so reporting space issues is not useful, and it
-          # creates auto-correct conflicts.
-          if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             block_length(node) > 0
-            return
-          end
-
           left_brace = node.loc.begin
           right_brace = node.loc.end
 
@@ -33,56 +24,58 @@ module RuboCop
         private
 
         def check_inside(node, left_brace, right_brace)
-          sb = node.source_range.source_buffer
-
           if left_brace.end_pos == right_brace.begin_pos
-            adjacent_braces(sb, left_brace, right_brace)
+            adjacent_braces(left_brace, right_brace)
           else
-            range = Parser::Source::Range.new(sb, left_brace.end_pos,
-                                              right_brace.begin_pos)
+            range = range_between(left_brace.end_pos, right_brace.begin_pos)
             inner = range.source
 
             if inner =~ /\S/
-              braces_with_contents_inside(node, inner, sb)
+              braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
-              offense(sb, range.begin_pos, range.end_pos,
+              offense(range.begin_pos, range.end_pos,
                       'Space inside empty braces detected.')
             end
           end
         end
 
-        def adjacent_braces(sb, left_brace, right_brace)
+        def adjacent_braces(left_brace, right_brace)
           return if style_for_empty_braces != :space
 
-          offense(sb, left_brace.begin_pos, right_brace.end_pos,
+          offense(left_brace.begin_pos, right_brace.end_pos,
                   'Space missing inside empty braces.')
         end
 
-        def braces_with_contents_inside(node, inner, sb)
+        def braces_with_contents_inside(node, inner)
           _method, args, _body = *node
-          left_brace = node.loc.begin
-          right_brace = node.loc.end
           args_delimiter = args.loc.begin # Can be ( | or nil.
 
+          check_left_brace(inner, node.loc.begin, args_delimiter)
+          check_right_brace(inner, node.loc.end, block_length(node))
+        end
+
+        def check_left_brace(inner, left_brace, args_delimiter)
           if inner =~ /^\S/
-            no_space_inside_left_brace(left_brace, args_delimiter, sb)
+            no_space_inside_left_brace(left_brace, args_delimiter)
           else
-            space_inside_left_brace(left_brace, args_delimiter, sb)
+            space_inside_left_brace(left_brace, args_delimiter)
           end
+        end
 
-          if inner =~ /\S$/ && block_length(node).zero?
-            no_space(sb, right_brace.begin_pos, right_brace.end_pos,
+        def check_right_brace(inner, right_brace, block_length)
+          if inner =~ /\S$/ && block_length.zero?
+            no_space(right_brace.begin_pos, right_brace.end_pos,
                      'Space missing inside }.')
           else
-            space_inside_right_brace(right_brace, sb)
+            space_inside_right_brace(right_brace)
           end
         end
 
-        def no_space_inside_left_brace(left_brace, args_delimiter, sb)
+        def no_space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             if left_brace.end_pos == args_delimiter.begin_pos &&
                cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
+              offense(left_brace.begin_pos, args_delimiter.end_pos,
                       'Space between { and | missing.') do
                 opposite_style_detected
               end
@@ -91,22 +84,22 @@ module RuboCop
             # We indicate the position after the left brace. Otherwise it's
             # difficult to distinguish between space missing to the left and to
             # the right of the brace in autocorrect.
-            no_space(sb, left_brace.end_pos, left_brace.end_pos + 1,
+            no_space(left_brace.end_pos, left_brace.end_pos + 1,
                      'Space missing inside {.')
           end
         end
 
-        def space_inside_left_brace(left_brace, args_delimiter, sb)
+        def space_inside_left_brace(left_brace, args_delimiter)
           if pipe?(args_delimiter)
             unless cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.end_pos, args_delimiter.begin_pos,
+              offense(left_brace.end_pos, args_delimiter.begin_pos,
                       'Space between { and | detected.') do
                 opposite_style_detected
               end
             end
           else
             brace_with_space = range_with_surrounding_space(left_brace, :right)
-            space(sb, brace_with_space.begin_pos + 1, brace_with_space.end_pos,
+            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
                   'Space inside { detected.')
           end
         end
@@ -115,30 +108,30 @@ module RuboCop
           args_delimiter && args_delimiter.is?('|')
         end
 
-        def space_inside_right_brace(right_brace, sb)
+        def space_inside_right_brace(right_brace)
           brace_with_space = range_with_surrounding_space(right_brace, :left)
-          space(sb, brace_with_space.begin_pos, brace_with_space.end_pos - 1,
+          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
                 'Space inside } detected.')
         end
 
-        def no_space(sb, begin_pos, end_pos, msg)
+        def no_space(begin_pos, end_pos, msg)
           if style == :space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+            offense(begin_pos, end_pos, msg) { opposite_style_detected }
           else
             correct_style_detected
           end
         end
 
-        def space(sb, begin_pos, end_pos, msg)
+        def space(begin_pos, end_pos, msg)
           if style == :no_space
-            offense(sb, begin_pos, end_pos, msg) { opposite_style_detected }
+            offense(begin_pos, end_pos, msg) { opposite_style_detected }
           else
             correct_style_detected
           end
         end
 
-        def offense(sb, begin_pos, end_pos, msg)
-          range = Parser::Source::Range.new(sb, begin_pos, end_pos)
+        def offense(begin_pos, end_pos, msg)
+          range = range_between(begin_pos, end_pos)
           add_offense(range, range, msg) { yield if block_given? }
         end
 

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

@@ -13,21 +13,37 @@ module RuboCop
         MSG = 'Space inside %s.'.freeze
 
         def on_hash(node)
-          b_ix = index_of_first_token(node)
           tokens = processed_source.tokens
 
-          # Hash literal with braces?
-          return unless tokens[b_ix].type == :tLBRACE
+          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
 
-          e_ix = index_of_last_token(node)
-          return unless tokens[e_ix].type == :tRCURLY
-
-          check(tokens[b_ix], tokens[b_ix + 1])
-          check(tokens[e_ix - 1], tokens[e_ix]) unless b_ix == e_ix - 1
+            check(tokens[end_index - 1], tokens[end_index])
+          end
         end
 
         private
 
+        def hash_literal_with_braces(node)
+          tokens = processed_source.tokens
+          begin_index = index_of_first_token(node)
+          return unless left_brace?(tokens[begin_index])
+
+          end_index = index_of_last_token(node)
+          return unless right_brace?(tokens[end_index])
+
+          yield begin_index, end_index
+        end
+
+        def left_brace?(token)
+          token.type == :tLBRACE
+        end
+
+        def right_brace?(token)
+          token.type == :tRCURLY
+        end
+
         def check(t1, t2)
           # No offense if line break inside.
           return if t1.pos.line < t2.pos.line
@@ -61,17 +77,16 @@ module RuboCop
           range = expect_space ? brace : space_range(brace)
           add_offense(range, range,
                       message(brace, is_empty_braces, expect_space)) do
-            if expect_space
-              if t1.text == t2.text
-                ambiguous_style_detected(:no_space, :compact)
-              else
-                unexpected_style_detected(:no_space)
-              end
-            elsif t1.text == t2.text
-              unexpected_style_detected(:space)
-            else
-              ambiguous_style_detected(:space, :compact)
-            end
+            style = expect_space ? :no_space : :space
+            ambiguous_or_unexpected_style_detected(style, t1.text == t2.text)
+          end
+        end
+
+        def ambiguous_or_unexpected_style_detected(style, is_match)
+          if is_match
+            ambiguous_style_detected(style, :compact)
+          else
+            unexpected_style_detected(style)
           end
         end
 
@@ -119,16 +134,16 @@ module RuboCop
           src = range.source_buffer.source
           end_pos = range.end_pos
           end_pos += 1 while src[end_pos] =~ /[ \t]/
-          Parser::Source::Range.new(range.source_buffer,
-                                    range.begin_pos + 1, end_pos)
+
+          range_between(range.begin_pos + 1, end_pos)
         end
 
         def range_of_space_to_the_left(range)
           src = range.source_buffer.source
           begin_pos = range.begin_pos
           begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
-          Parser::Source::Range.new(range.source_buffer, begin_pos,
-                                    range.end_pos - 1)
+
+          range_between(begin_pos, range.end_pos - 1)
         end
       end
     end

data/lib/rubocop/cop/style/space_inside_percent_literal_delimiters.rb

@@ -24,7 +24,7 @@ module RuboCop
         END_REGEX = /(?<!\\)( +)\z/
 
         def on_array(node)
-          process(node, *%w(%i %I %w %W))
+          process(node, '%i', '%I', '%w', '%W')
         end
 
         def on_percent_literal(node)

data/lib/rubocop/cop/style/space_inside_string_interpolation.rb

@@ -19,25 +19,39 @@ module RuboCop
         SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
 
         def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
+          each_style_violation(node) do |final_node, msg|
+            add_offense(final_node, :expression, msg)
+          end
+        end
+
+        private
+
+        def each_style_violation(node)
+          node.each_child_node(:begin) do |begin_node|
             final_node = begin_node.children.last
             next unless final_node
 
-            interp = final_node.source_range
-            interp_with_surrounding_space = range_with_surrounding_space(interp)
-            if style == :no_space
-              if interp_with_surrounding_space != interp
-                add_offense(final_node, :expression, NO_SPACE_MSG)
-              end
-            elsif style == :space
-              if interp_with_surrounding_space.source != " #{interp.source} "
-                add_offense(final_node, :expression, SPACE_MSG)
-              end
+            if style == :no_space && space_on_any_side?(final_node)
+              yield final_node, NO_SPACE_MSG
+            elsif style == :space && !space_on_each_side?(final_node)
+              yield final_node, SPACE_MSG
             end
           end
         end
 
-        private
+        def space_on_any_side?(node)
+          interp = node.source_range
+          interp_with_surrounding_space = range_with_surrounding_space(interp)
+
+          interp_with_surrounding_space != interp
+        end
+
+        def space_on_each_side?(node)
+          interp = node.source_range
+          interp_with_surrounding_space = range_with_surrounding_space(interp)
+
+          interp_with_surrounding_space.source == " #{interp.source} "
+        end
 
         def autocorrect(node)
           new_source = style == :no_space ? node.source : " #{node.source} "