rubocop 0.41.2 → 0.42.0

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

@@ -56,7 +56,7 @@ module RuboCop
 
           correct_column = expected_column(node, elements)
           @column_delta = correct_column - right_paren.column
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT

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

@@ -23,7 +23,7 @@ module RuboCop
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            length = first_word.length + colon.to_s.length + space.to_s.length
+            length = concat_length(first_word, colon, space)
             add_offense(comment, annotation_range(comment, margin, length),
                         format(note ? MSG : MISSING_NOTE, first_word))
           end
@@ -32,7 +32,17 @@ module RuboCop
         private
 
         def first_comment_line?(comments, ix)
-          ix == 0 || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        end
+
+        def autocorrect(comment)
+          margin, first_word, colon, space, note = split_comment(comment)
+          return if note.nil?
+
+          length = concat_length(first_word, colon, space)
+          range = annotation_range(comment, margin, length)
+
+          ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
 
         def annotation_range(comment, margin, length)
@@ -41,18 +51,8 @@ module RuboCop
           Parser::Source::Range.new(source_buffer, start, start + length)
         end
 
-        def autocorrect(comment)
-          margin, first_word, colon, space, note = split_comment(comment)
-          start = comment.loc.expression.begin_pos + margin.length
-          return if note.nil?
-
-          lambda do |corrector|
-            length = first_word.length + colon.to_s.length + space.to_s.length
-            range = Parser::Source::Range.new(comment.loc.expression.source,
-                                              start,
-                                              start + length)
-            corrector.replace(range, "#{first_word.upcase}: ")
-          end
+        def concat_length(*args)
+          args.reduce(0) { |a, e| a + e.to_s.length }
         end
 
         def correct_annotation?(first_word, colon, space, note)

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

@@ -24,7 +24,7 @@ module RuboCop
           column = comment.loc.column
 
           @column_delta = correct_comment_indentation - column
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           if two_alternatives?(next_line)
             # Try the other

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

@@ -420,6 +420,21 @@ module RuboCop
                                     condition.loc.expression.begin_pos)
         end
 
+        def correct_if_branches(corrector, cop, node)
+          if_branch, elsif_branches, else_branch = extract_tail_branches(node)
+
+          corrector.insert_before(node.source_range, lhs(if_branch))
+          replace_branch_assignment(corrector, if_branch)
+          correct_branches(corrector, elsif_branches)
+          replace_branch_assignment(corrector, else_branch)
+          corrector.insert_before(node.loc.end, indent(cop, lhs(if_branch)))
+        end
+
+        def replace_branch_assignment(corrector, branch)
+          _variable, *_operator, assignment = *branch
+          corrector.replace(branch.source_range, assignment.source)
+        end
+
         def correct_branches(corrector, branches)
           branches.each do |branch|
             *_, assignment = *branch
@@ -495,18 +510,7 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(cop, node)
-            if_branch, elsif_branches, else_branch = extract_tail_branches(node)
-            _variable, *_operator, if_assignment = *if_branch
-            _else_variable, *_operator, else_assignment = *else_branch
-
-            lambda do |corrector|
-              corrector.insert_before(node.source_range, lhs(if_branch))
-              corrector.replace(if_branch.source_range, if_assignment.source)
-              correct_branches(corrector, elsif_branches)
-              corrector.replace(else_branch.source_range,
-                                else_assignment.source)
-              corrector.insert_before(node.loc.end, indent(cop, lhs(if_branch)))
-            end
+            ->(corrector) { correct_if_branches(corrector, cop, node) }
           end
 
           def move_assignment_inside_condition(node)
@@ -562,13 +566,11 @@ module RuboCop
 
           def correct(cop, node)
             when_branches, else_branch = extract_tail_branches(node)
-            _variable, *_operator, else_assignment = *else_branch
 
             lambda do |corrector|
               corrector.insert_before(node.source_range, lhs(else_branch))
               correct_branches(corrector, when_branches)
-              corrector.replace(else_branch.source_range,
-                                else_assignment.source)
+              replace_branch_assignment(corrector, else_branch)
 
               corrector.insert_before(node.loc.end,
                                       indent(cop, lhs(else_branch)))
@@ -623,21 +625,18 @@ module RuboCop
       class UnlessCorrector
         class << self
           include ConditionalAssignmentHelper
+          include ConditionalCorrectorHelper
 
           def correct(cop, node)
+            ->(corrector) { correct_if_branches(corrector, cop, node) }
+          end
+
+          private
+
+          def extract_tail_branches(node)
             _condition, else_branch, if_branch = *node
-            if_branch = tail(if_branch)
-            else_branch = tail(else_branch)
-            _variable, *_operator, if_assignment = *if_branch
-            _else_variable, *_operator, else_assignment = *else_branch
 
-            lambda do |corrector|
-              corrector.insert_before(node.source_range, lhs(if_branch))
-              corrector.replace(if_branch.source_range, if_assignment.source)
-              corrector.replace(else_branch.source_range,
-                                else_assignment.source)
-              corrector.insert_before(node.loc.end, indent(cop, lhs(if_branch)))
-            end
+            [tail(if_branch), [], tail(else_branch)]
           end
         end
       end

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

@@ -34,25 +34,27 @@ module RuboCop
           receiver, _method_name, *_args = *node
 
           receiver_line = receiver.source_range.end.line
-
-          if node.loc.selector
-            selector_line = node.loc.selector.line
-          else
-            # l.(1) has no selector, so we use the opening parenthesis instead
-            selector_line = node.loc.begin.line
-          end
+          selector_line = selector_range(node).line
 
           # receiver and selector are on the same line
           return true if selector_line == receiver_line
 
           dot_line = node.loc.dot.line
 
-          # don't register an offense if there is a line comment between
-          # the dot and the selector
-          # otherwise, we might break the code while "correcting" it
-          # (even if there is just an extra blank line, treat it the same)
-          return true if (selector_line - dot_line) > 1
+          # don't register an offense if there is a line comment between the
+          # dot and the selector otherwise, we might break the code while
+          # "correcting" it (even if there is just an extra blank line, treat
+          # it the same)
+          return true if line_between?(selector_line, dot_line)
 
+          correct_dot_position_style?(dot_line, selector_line)
+        end
+
+        def line_between?(first_line, second_line)
+          (first_line - second_line) > 1
+        end
+
+        def correct_dot_position_style?(dot_line, selector_line)
           case style
           when :leading then dot_line == selector_line
           when :trailing then dot_line != selector_line
@@ -61,23 +63,26 @@ module RuboCop
 
         def autocorrect(node)
           receiver, _method_name, *_args = *node
-          if node.loc.selector
-            selector = node.loc.selector
-          else
-            # l.(1) has no selector, so we use the opening parenthesis instead
-            selector = node.loc.begin
-          end
 
           lambda do |corrector|
             corrector.remove(node.loc.dot)
             case style
             when :leading
-              corrector.insert_before(selector, '.')
+              corrector.insert_before(selector_range(node), '.')
             when :trailing
               corrector.insert_after(receiver.source_range, '.')
             end
           end
         end
+
+        def selector_range(node)
+          if node.loc.selector
+            node.loc.selector
+          else
+            # l.(1) has no selector, so we use the opening parenthesis instead
+            node.loc.begin
+          end
+        end
       end
     end
   end

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

@@ -12,30 +12,44 @@ module RuboCop
       #
       # @example
       #   @bad
-      #   (0..10).each { }
+      #   (1..5).each { }
       #
       #   @good
-      #   10.times { }
+      #   5.times { }
+      #
+      # @example
+      #   @bad
+      #   (0...10).each {}
+      #
+      #   @good
+      #   10.times {}
       class EachForSimpleLoop < Cop
+        MSG = 'Use `Integer#times` for a simple loop which iterates a fixed ' \
+              'number of times.'.freeze
+
         def on_block(node)
-          if bad_each_range(node)
+          if offending_each_range(node)
             send_node, = *node
             range = send_node.receiver.source_range.join(send_node.loc.selector)
-            add_offense(node, range, 'Use `Integer#times` for a simple loop ' \
-                                     'which iterates a fixed number of times.')
+            add_offense(node, range)
           end
         end
 
+        private
+
         def autocorrect(node)
           lambda do |corrector|
-            min, max = bad_each_range(node)
+            range_type, min, max = offending_each_range(node)
+
+            max += 1 if range_type == :irange
+
             corrector.replace(node.children.first.source_range,
                               "#{max - min}.times")
           end
         end
 
-        def_node_matcher :bad_each_range, <<-PATTERN
-          (block (send (begin ({irange erange} (int $_) (int $_))) :each) (args) ...)
+        def_node_matcher :offending_each_range, <<-PATTERN
+          (block (send (begin (${irange erange} (int $_) (int $_))) :each) (args) ...)
         PATTERN
       end
     end

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

@@ -33,7 +33,17 @@ module RuboCop
           return unless first_argument_returned?(args, return_value)
           return if accumulator_param_assigned_to?(body, args)
 
-          add_offense(method, :selector, format(MSG, method_name))
+          add_offense(node, method.loc.selector, format(MSG, method_name))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method, args, _body = *node
+            corrector.replace(method.loc.selector, 'each_with_object')
+            first_arg, second_arg = *args
+            corrector.replace(first_arg.loc.expression, second_arg.source)
+            corrector.replace(second_arg.loc.expression, first_arg.source)
+          end
         end
 
         private

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

@@ -100,7 +100,7 @@ module RuboCop
           return unless begins_its_line?(else_range)
 
           @column_delta = effective_column(base_range) - else_range.column
-          return if @column_delta == 0
+          return if @column_delta.zero?
 
           add_offense(else_range, else_range,
                       format(MSG, else_range.source, base_range.source[/^\S*/]))

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

@@ -19,21 +19,28 @@ module RuboCop
             lines << token.pos.line
           end
 
-          prev_line = 1
+          each_extra_empty_line(lines.sort) do |range|
+            add_offense(range, range)
+          end
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
 
-          lines.sort.each do |cur_line|
-            line_diff = cur_line - prev_line
+        private
 
-            if line_diff > LINE_OFFSET
+        def each_extra_empty_line(lines)
+          prev_line = 1
+
+          lines.each do |cur_line|
+            if exceeds_line_offset?(cur_line - prev_line)
               # we need to be wary of comments since they
               # don't show up in the tokens
               ((prev_line + 1)...cur_line).each do |line|
-                # we check if the prev and current lines are empty
-                next unless processed_source[line - 2].empty? &&
-                            processed_source[line - 1].empty?
+                next unless previous_and_current_lines_empty?(line)
 
-                range = source_range(processed_source.buffer, line, 0)
-                add_offense(range, range)
+                yield source_range(processed_source.buffer, line, 0)
               end
             end
 
@@ -41,8 +48,12 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
+        def exceeds_line_offset?(line_diff)
+          line_diff > LINE_OFFSET
+        end
+
+        def previous_and_current_lines_empty?(line)
+          processed_source[line - 2].empty? && processed_source[line - 1].empty?
         end
       end
     end

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

@@ -23,12 +23,7 @@ module RuboCop
             send_line = node.loc.line
             previous_line = processed_source[send_line - 2]
             next_line = processed_source[send_line]
-
-            line = Parser::Source::Range.new(
-              processed_source.buffer,
-              node.source_range.begin_pos - node.loc.column,
-              node.source_range.end_pos
-            )
+            line = line_range(node)
 
             unless previous_line_empty?(previous_line)
               corrector.insert_before(line, "\n")
@@ -42,6 +37,14 @@ module RuboCop
 
         private
 
+        def line_range(node)
+          Parser::Source::Range.new(
+            processed_source.buffer,
+            node.source_range.begin_pos - node.loc.column,
+            node.source_range.end_pos
+          )
+        end
+
         def previous_line_ignoring_comments(processed_source, send_line)
           processed_source[0..send_line - 2].reverse.find do |line|
             !comment_line?(line)

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

@@ -9,11 +9,23 @@ module RuboCop
       #
       # @example
       #
-      #   something do
+      #   # EnforcedStyle: empty_lines
+      #
+      #   # good
+      #
+      #   foo do |bar|
       #
       #     ...
+      #
       #   end
       #
+      #   # EnforcedStyle: no_empty_lines
+      #
+      #   # good
+      #
+      #   foo do |bar|
+      #     ...
+      #   end
       class EmptyLinesAroundBlockBody < Cop
         include EmptyLinesAroundBody
 
@@ -21,20 +33,8 @@ module RuboCop
 
         def on_block(node)
           _send, _args, body = *node
-          check(node, body)
-        end
-
-        private
-
-        def check(node, body)
-          return unless body || style == :no_empty_lines
 
-          start_line = node.loc.begin.line
-          end_line = node.loc.end.line
-
-          return if start_line == end_line
-
-          check_source(start_line, end_line)
+          check(node, body)
         end
       end
     end

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

@@ -4,19 +4,22 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks if empty lines around the bodies of classes match the
-      # configuration.
+      # This cops checks if empty lines around the bodies of classes match
+      # the configuration.
       #
       # @example
       #
-      #   class Test
+      #   EnforcedStyle: empty_lines
       #
-      #      def something
+      #   # good
+      #
+      #   class Foo
+      #
+      #      def bar
       #        ...
       #      end
       #
       #   end
-      #
       class EmptyLinesAroundClassBody < Cop
         include EmptyLinesAroundBody