rubocop 0.40.0 → 0.41.0

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

@@ -54,18 +54,29 @@ module RuboCop
           return unless right_paren
           return unless begins_its_line?(right_paren)
 
-          left_paren = node.loc.begin
-
-          correct_column = if line_break_after_left_paren?(left_paren, elements)
-                             left_paren.source_line =~ /\S/
-                           else
-                             left_paren.column
-                           end
+          correct_column = expected_column(node, elements)
           @column_delta = correct_column - right_paren.column
           return if @column_delta == 0
 
+          left_paren = node.loc.begin
           msg = correct_column == left_paren.column ? MSG_ALIGN : MSG_INDENT
-          add_offense(node.loc.end, node.loc.end, msg)
+          add_offense(right_paren, right_paren, msg)
+        end
+
+        def expected_column(node, elements)
+          left_paren = node.loc.begin
+
+          if node.send_type? && fixed_parameter_indentation? ||
+             line_break_after_left_paren?(left_paren, elements)
+            left_paren.source_line =~ /\S/
+          else
+            left_paren.column
+          end
+        end
+
+        def fixed_parameter_indentation?
+          config.for_cop('Style/AlignParameters')['EnforcedStyle'] ==
+            'with_fixed_indentation'
         end
 
         def line_break_after_left_paren?(left_paren, elements)

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

@@ -17,11 +17,9 @@ module RuboCop
         private
 
         def check(comment)
-          lines = processed_source.lines
-          own_line = lines[comment.loc.line - 1]
-          return unless own_line =~ /\A\s*#/
+          return unless own_line_comment?(comment)
 
-          next_line = lines[comment.loc.line..-1].find { |line| !line.blank? }
+          next_line = line_after_comment(comment)
           correct_comment_indentation = correct_indentation(next_line)
           column = comment.loc.column
 
@@ -33,13 +31,23 @@ module RuboCop
             correct_comment_indentation += configured_indentation_width
             # We keep @column_delta unchanged so that autocorrect changes to
             # the preferred style of aligning the comment with the keyword.
+            return if column == correct_comment_indentation
           end
 
-          return if column == correct_comment_indentation
           add_offense(comment, comment.loc.expression,
                       format(MSG, column, correct_comment_indentation))
         end
 
+        def own_line_comment?(comment)
+          own_line = processed_source.lines[comment.loc.line - 1]
+          own_line =~ /\A\s*#/
+        end
+
+        def line_after_comment(comment)
+          lines = processed_source.lines
+          lines[comment.loc.line..-1].find { |line| !line.blank? }
+        end
+
         def correct_indentation(next_line)
           return 0 unless next_line
 

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

@@ -213,30 +213,30 @@ module RuboCop
         ASSIGNMENT_TYPES.each do |type|
           define_method "on_#{type}" do |node|
             return if part_of_ignored_node?(node)
+            return unless style == :assign_inside_condition
+
             check_assignment_to_condition(node)
           end
         end
 
         def on_send(node)
           return unless assignment_type?(node)
+          return unless style == :assign_inside_condition
+
           check_assignment_to_condition(node)
         end
 
         def check_assignment_to_condition(node)
-          return unless style == :assign_inside_condition
           ignore_node(node)
-          *_variable, assignment = *node
-          if assignment.respond_to?(:type)
-            if assignment.begin_type? && assignment.children.size == 1
-              assignment, = *assignment
-            end
 
-            return unless CONDITION_TYPES.include?(assignment.type)
-          end
+          assignment = assignment_node(node)
+          return unless condition?(assignment)
+
           _condition, *branches, else_branch = *assignment
           return unless else_branch # empty else
           return if single_line_conditions_only? &&
                     [*branches, else_branch].any?(&:begin_type?)
+
           add_offense(node, :expression, ASSIGN_TO_CONDITION_MSG)
         end
 
@@ -274,6 +274,20 @@ module RuboCop
 
         private
 
+        def assignment_node(node)
+          *_variable, assignment = *node
+
+          if assignment.begin_type? && assignment.children.size == 1
+            assignment, = *assignment
+          end
+
+          assignment
+        end
+
+        def condition?(node)
+          CONDITION_TYPES.include?(node.type)
+        end
+
         def move_assignment_outside_condition(node)
           if ternary?(node)
             TernaryCorrector.correct(node)
@@ -381,14 +395,7 @@ module RuboCop
       module ConditionalCorrectorHelper
         def remove_whitespace_in_branches(corrector, branch, condition, column)
           branch.each_node do |child|
-            child_expression = child.loc.expression
-            white_space =
-              Parser::Source::Range.new(child_expression.source_buffer,
-                                        child_expression.begin_pos -
-                                         (child.loc.expression.column -
-                                          column - 2),
-                                        child_expression.begin_pos)
-
+            white_space = white_space_range(child, column)
             corrector.remove(white_space) if white_space.source.strip.empty?
           end
 
@@ -397,6 +404,15 @@ module RuboCop
           end
         end
 
+        def white_space_range(node, column)
+          expression = node.loc.expression
+          begin_pos = expression.begin_pos - (expression.column - column - 2)
+
+          Parser::Source::Range.new(expression.source_buffer,
+                                    begin_pos,
+                                    expression.begin_pos)
+        end
+
         def assignment(node)
           *_, condition = *node
           Parser::Source::Range.new(node.loc.expression.source_buffer,
@@ -439,22 +455,36 @@ module RuboCop
 
           def move_assignment_inside_condition(node)
             *_var, rhs = *node
-            condition, = *rhs if rhs.begin_type? && rhs.children.size == 1
+            if_branch, else_branch = extract_branches(node)
             assignment = assignment(node)
-            _condition, if_branch, else_branch = *(condition || rhs)
 
             lambda do |corrector|
+              remove_parentheses(corrector, rhs) if Util.parentheses?(rhs)
               corrector.remove(assignment)
-              if rhs.begin_type?
-                corrector.remove(rhs.loc.begin)
-                corrector.remove(rhs.loc.end)
-              end
-              corrector.insert_before(if_branch.loc.expression,
-                                      assignment.source)
-              corrector.insert_before(else_branch.loc.expression,
-                                      assignment.source)
+
+              move_branch_inside_condition(corrector, if_branch, assignment)
+              move_branch_inside_condition(corrector, else_branch, assignment)
             end
           end
+
+          private
+
+          def extract_branches(node)
+            *_var, rhs = *node
+            condition, = *rhs if rhs.begin_type? && rhs.children.size == 1
+            _condition, if_branch, else_branch = *(condition || rhs)
+
+            [if_branch, else_branch]
+          end
+
+          def remove_parentheses(corrector, node)
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+
+          def move_branch_inside_condition(corrector, branch, assignment)
+            corrector.insert_before(branch.loc.expression, assignment.source)
+          end
         end
       end
 
@@ -465,7 +495,7 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(cop, node)
-            if_branch, elsif_branches, else_branch = extract_branches(node)
+            if_branch, elsif_branches, else_branch = extract_tail_branches(node)
             _variable, *_operator, if_assignment = *if_branch
             _else_variable, *_operator, else_assignment = *else_branch
 
@@ -482,36 +512,44 @@ module RuboCop
           def move_assignment_inside_condition(node)
             column = node.loc.expression.column
             *_var, condition = *node
-            _condition, if_branch, else_branch = *condition
-            elsif_branches, else_branch = expand_elses(else_branch)
             assignment = assignment(node)
 
             lambda do |corrector|
               corrector.remove(assignment)
 
-              [if_branch, *elsif_branches, else_branch].each do |branch|
-                branch_assignment = tail(branch)
-                corrector.insert_before(branch_assignment.loc.expression,
-                                        assignment.source)
-
-                remove_whitespace_in_branches(corrector, branch,
-                                              condition, column)
-
-                corrector
-                  .remove_preceding(branch.parent.loc.else,
-                                    branch.parent.loc.else.column - column)
+              extract_branches(condition).flatten.each do |branch|
+                move_branch_inside_condition(corrector, branch, condition,
+                                             assignment, column)
               end
             end
           end
 
           private
 
+          def extract_tail_branches(node)
+            if_branch, elsif_branches, else_branch = extract_branches(node)
+            elsif_branches.map! { |branch| tail(branch) }
+
+            [tail(if_branch), elsif_branches, tail(else_branch)]
+          end
+
           def extract_branches(node)
             _condition, if_branch, else_branch = *node
             elsif_branches, else_branch = expand_elses(else_branch)
-            elsif_branches.map! { |branch| tail(branch) }
 
-            [tail(if_branch), elsif_branches, tail(else_branch)]
+            [if_branch, elsif_branches, else_branch]
+          end
+
+          def move_branch_inside_condition(corrector, branch, condition,
+                                           assignment, column)
+            branch_assignment = tail(branch)
+            corrector.insert_before(branch_assignment.loc.expression,
+                                    assignment.source)
+
+            remove_whitespace_in_branches(corrector, branch, condition, column)
+
+            branch_else = branch.parent.loc.else
+            corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
       end
@@ -523,10 +561,7 @@ module RuboCop
           include ConditionalCorrectorHelper
 
           def correct(cop, node)
-            _condition, *when_branches, else_branch = *node
-            else_branch = tail(else_branch)
-            when_branches = expand_when_branches(when_branches)
-            when_branches.map! { |when_branch| tail(when_branch) }
+            when_branches, else_branch = extract_tail_branches(node)
             _variable, *_operator, else_assignment = *else_branch
 
             lambda do |corrector|
@@ -543,27 +578,44 @@ module RuboCop
           def move_assignment_inside_condition(node)
             column = node.loc.expression.column
             *_var, condition = *node
-            _condition, *when_branches, else_branch = *condition
-            when_branches = expand_when_branches(when_branches)
             assignment = assignment(node)
 
             lambda do |corrector|
               corrector.remove(assignment)
 
-              [*when_branches, else_branch].each do |branch|
-                branch_assignment = tail(branch)
-                corrector.insert_before(branch_assignment.loc.expression,
-                                        assignment.source)
-
-                remove_whitespace_in_branches(corrector, branch,
-                                              condition, column)
-
-                corrector
-                  .remove_preceding(branch.parent.loc.keyword,
-                                    branch.parent.loc.keyword.column - column)
+              extract_branches(condition).flatten.each do |branch|
+                move_branch_inside_condition(corrector, branch, condition,
+                                             assignment, column)
               end
             end
           end
+
+          private
+
+          def extract_tail_branches(node)
+            when_branches, else_branch = extract_branches(node)
+            when_branches.map! { |branch| tail(branch) }
+            [when_branches, tail(else_branch)]
+          end
+
+          def extract_branches(node)
+            _condition, *when_branches, else_branch = *node
+            when_branches = expand_when_branches(when_branches)
+            [when_branches, else_branch]
+          end
+
+          def move_branch_inside_condition(corrector, branch, condition,
+                                           assignment, column)
+            branch_assignment = tail(branch)
+            corrector.insert_before(branch_assignment.loc.expression,
+                                    assignment.source)
+
+            remove_whitespace_in_branches(corrector, branch, condition, column)
+
+            parent_keyword = branch.parent.loc.keyword
+            corrector.remove_preceding(parent_keyword,
+                                       parent_keyword.column - column)
+          end
         end
       end
 

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

@@ -65,7 +65,9 @@ module RuboCop
 
           # As long as there's at least one comment line that isn't an
           # annotation, it's OK.
-          preceding_comments.any? { |comment| !annotation?(comment) }
+          preceding_comments.any? do |comment|
+            !annotation?(comment) && !interpreter_directive_comment?(comment)
+          end
         end
 
         def preceding_comments(node, ast_with_comments)
@@ -96,6 +98,10 @@ module RuboCop
 
           nodoc_comment?(node.ancestors.first, ast_with_comments, true)
         end
+
+        def interpreter_directive_comment?(comment)
+          comment.text =~ /^#\s*(frozen_string_literal|encoding):/
+        end
       end
     end
   end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for loops which iterate a constant number of times,
+      # using a Range literal and `#each`. This can be done more readably using
+      # `Integer#times`.
+      #
+      # This check only applies if the block takes no parameters.
+      #
+      # @example
+      #   @bad
+      #   (0..10).each { }
+      #
+      #   @good
+      #   10.times { }
+      class EachForSimpleLoop < Cop
+        def on_block(node)
+          if bad_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.')
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            min, max = bad_each_range(node)
+            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) ...)
+        PATTERN
+      end
+    end
+  end
+end

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

@@ -23,35 +23,46 @@ module RuboCop
 
         def on_block(node)
           method, args, body = *node
-
-          # filter out super and zsuper nodes
-          return unless method.type == :send
+          return unless reduce_method?(method)
 
           _, method_name, method_arg = *method
-
-          return unless METHODS.include? method_name
-          return if method_arg && method_arg.basic_literal?
+          return if simple_method_arg?(method_arg)
 
           return_value = return_value(body)
           return unless return_value
-
           return unless first_argument_returned?(args, return_value)
+          return if accumulator_param_assigned_to?(body, args)
+
+          add_offense(method, :selector, format(MSG, method_name))
+        end
+
+        private
 
-          # if the accumulator parameter is assigned to in the block,
-          # then we can't convert to each_with_object
+        def reduce_method?(method)
+          return false unless method.send_type?
+
+          _, method_name, _method_arg = *method
+          METHODS.include? method_name
+        end
+
+        def simple_method_arg?(method_arg)
+          method_arg && method_arg.basic_literal?
+        end
+
+        # if the accumulator parameter is assigned to in the block,
+        # then we can't convert to each_with_object
+        def accumulator_param_assigned_to?(body, args)
           first_arg, = *args
           accumulator_var, = *first_arg
-          return if body.each_descendant.any? do |n|
+
+          body.each_descendant.any? do |n|
             next unless n.assignment?
+
             lhs, _rhs = *n
             lhs.equal?(accumulator_var)
           end
-
-          add_offense(method, :selector, format(MSG, method_name))
         end
 
-        private
-
         def return_value(body)
           return unless body