rubocop 0.31.0 → 0.32.0

data/lib/rubocop/cop/performance/size.rb

@@ -27,12 +27,13 @@ module RuboCop
         MSG = 'Use `size` instead of `count`.'
 
         def on_send(node)
-          receiver, method = *node
+          receiver, method, args = *node
 
           return if receiver.nil?
           return unless method == :count
           return unless array?(receiver) || hash?(receiver)
           return if node.parent && node.parent.block_type?
+          return if args && args.block_pass_type?
 
           add_offense(node, node.loc.selector)
         end

data/lib/rubocop/cop/rails/time_zone.rb

@@ -39,7 +39,7 @@ module RuboCop
 
         DANGER_METHODS = [:now, :local, :new, :strftime, :parse, :at]
 
-        ACCEPTED_METHODS = [:in_time_zone, :utc,
+        ACCEPTED_METHODS = [:in_time_zone, :utc, :getlocal,
                             :iso8601, :jisx0301, :rfc3339,
                             :to_i, :to_f]
 
@@ -68,13 +68,9 @@ module RuboCop
 
         def build_message(klass, method_name, node)
           if acceptable?
-            accepted_methods = ACCEPTED_METHODS.map do |am|
-              "`#{klass}.#{method_name}.#{am}`"
-            end
-
             format(MSG_ACCEPTABLE,
                    "#{klass}.#{method_name}",
-                   accepted_methods.join(', ')
+                   acceptable_methods(klass, method_name, node).join(', ')
                   )
           else
             safe_method_name = safe_method(method_name, node)
@@ -146,6 +142,18 @@ module RuboCop
         def good_methods
           style == :always ? [:zone] : [:zone] + ACCEPTED_METHODS
         end
+
+        def acceptable_methods(klass, method_name, node)
+          acceptable = [
+            "`#{klass}.zone.#{safe_method(method_name, node)}`"
+          ]
+
+          ACCEPTED_METHODS.each do |am|
+            acceptable << "`#{klass}.#{method_name}.#{am}`"
+          end
+
+          acceptable
+        end
       end
     end
   end

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

@@ -231,9 +231,13 @@ module RuboCop
           key, value = *node
 
           lambda do |corrector|
-            adjust(corrector, key_delta, key.loc.expression)
-            adjust(corrector, separator_delta, node.loc.operator)
-            adjust(corrector, value_delta, value.loc.expression)
+            if value.nil?
+              adjust(corrector, key_delta, node.loc.expression)
+            else
+              adjust(corrector, key_delta, key.loc.expression)
+              adjust(corrector, separator_delta, node.loc.operator)
+              adjust(corrector, value_delta, value.loc.expression)
+            end
           end
         end
 

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

@@ -7,6 +7,7 @@ module RuboCop
       # if the last parameter is a hash.
       class BracesAroundHashParameters < Cop
         include ConfigurableEnforcedStyle
+        include AutocorrectUnlessChangingAST
 
         MSG = '%s curly braces around a hash parameter.'
 
@@ -28,9 +29,10 @@ module RuboCop
 
         def check(arg, args)
           if style == :braces && !braces?(arg)
-            add_offense(arg, :expression, format(MSG, 'Missing'))
+            add_offense(arg.parent, arg.loc.expression, format(MSG, 'Missing'))
           elsif style == :no_braces && braces?(arg)
-            add_offense(arg, :expression, format(MSG, 'Redundant'))
+            add_offense(arg.parent, arg.loc.expression,
+                        format(MSG, 'Redundant'))
           elsif style == :context_dependent
             check_context_dependent(arg, args)
           end
@@ -40,27 +42,53 @@ module RuboCop
           braces_around_2nd_from_end = args.length > 1 && args[-2].type == :hash
           if braces?(arg)
             unless braces_around_2nd_from_end
-              add_offense(arg, :expression, format(MSG, 'Redundant'))
+              add_offense(arg.parent, arg.loc.expression,
+                          format(MSG, 'Redundant'))
             end
           elsif braces_around_2nd_from_end
-            add_offense(arg, :expression, format(MSG, 'Missing'))
+            add_offense(arg.parent, arg.loc.expression, format(MSG, 'Missing'))
           end
         end
 
-        def autocorrect(node)
+        # We let AutocorrectUnlessChangingAST#autocorrect work with the send
+        # node, becuase that context is needed. When parsing the code to see if
+        # the AST has changed, a braceless hash would not be parsed as a hash
+        # otherwise.
+        def correction(send_node)
+          _receiver, _method_name, *args = *send_node
+          node = args.last
           lambda do |corrector|
             if braces?(node)
-              right_range = range_with_surrounding_space(node.loc.begin, :right)
-              corrector.remove(right_range)
-              left_range = range_with_surrounding_space(node.loc.end, :left)
-              corrector.remove(left_range)
+              remove_braces(corrector, node)
             else
-              corrector.insert_before(node.loc.expression, '{')
-              corrector.insert_after(node.loc.expression, '}')
+              add_braces(corrector, node)
             end
           end
         end
 
+        def remove_braces(corrector, node)
+          comments = processed_source.comments
+          right_brace_and_space = range_with_surrounding_space(node.loc.end,
+                                                               :left)
+          if comments.any? { |c| c.loc.line == right_brace_and_space.line }
+            # Removing a line break between a comment and the closing
+            # parenthesis would cause a syntax error, so we only remove the
+            # braces in that case.
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          else
+            left_brace_and_space = range_with_surrounding_space(node.loc.begin,
+                                                                :right)
+            corrector.remove(left_brace_and_space)
+            corrector.remove(right_brace_and_space)
+          end
+        end
+
+        def add_braces(corrector, node)
+          corrector.insert_before(node.loc.expression, '{')
+          corrector.insert_after(node.loc.expression, '}')
+        end
+
         def non_empty_hash?(arg)
           arg && arg.type == :hash && arg.children.any?
         end

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

@@ -8,6 +8,7 @@ module RuboCop
       #
       # It will register a separate offense for each misaligned *when*.
       class CaseIndentation < Cop
+        include AutocorrectAlignment
         include ConfigurableEnforcedStyle
 
         def on_case(case_node)
@@ -50,10 +51,6 @@ module RuboCop
           end
         end
 
-        def configured_indentation_width
-          config.for_cop('IndentationWidth')['Width']
-        end
-
         def parameter_name
           'IndentWhenRelativeTo'
         end
@@ -64,6 +61,23 @@ module RuboCop
           when :end  then case_node.location.end.column
           end
         end
+
+        def autocorrect(node)
+          when_column = node.location.keyword.column
+          source_buffer = node.loc.expression.source_buffer
+          begin_pos = node.loc.keyword.begin_pos
+          whitespace = Parser::Source::Range.new(source_buffer,
+                                                 begin_pos - when_column,
+                                                 begin_pos)
+          return false unless whitespace.source.strip.empty?
+
+          case_node = node.each_ancestor(:case).first
+          base_type = cop_config[parameter_name] == 'end' ? :end : :case
+          column = base_column(case_node, base_type)
+          column += configured_indentation_width if cop_config['IndentOneStep']
+
+          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+        end
       end
     end
   end

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

@@ -8,8 +8,11 @@ module RuboCop
       class CommentAnnotation < Cop
         include AnnotationComment
 
-        MSG = 'Annotation keywords should be all upper case, followed by a ' \
-              'colon and a space, then a note describing the problem.'
+        MSG = 'Annotation keywords like `%s` should be all upper case, ' \
+              'followed by a colon, and a space, ' \
+              'then a note describing the problem.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%s`, ' \
+                       'is missing a note.'
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
@@ -19,19 +22,31 @@ module RuboCop
 
             start = comment.loc.expression.begin_pos + margin.length
             length = first_word.length + colon.to_s.length + space.to_s.length
-            range = Parser::Source::Range.new(processed_source.buffer,
+            source_buffer = comment.loc.expression.source_buffer
+            range = Parser::Source::Range.new(source_buffer,
                                               start,
                                               start + length)
-            add_offense(range, range)
+            if note
+              add_offense(comment, range, format(MSG, first_word))
+            else
+              add_offense(comment, range, format(MISSING_NOTE, first_word))
+            end
           end
         end
 
         private
 
-        def autocorrect(range)
+        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|
-            annotation_keyword = range.source.split(/:?\s+/).first
-            corrector.replace(range, annotation_keyword.upcase << ': ')
+            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
         end
 

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

@@ -65,16 +65,22 @@ module RuboCop
         # Returns true if the node has a comment on the line above it that
         # isn't an annotation.
         def associated_comment?(node, ast_with_comments)
-          return false if ast_with_comments[node].empty?
+          preceding_comments = preceding_comments(node, ast_with_comments)
+          return false if preceding_comments.empty?
 
-          preceding_comment = ast_with_comments[node].last
-          distance = node.loc.keyword.line - preceding_comment.loc.line
+          distance = node.loc.keyword.line - preceding_comments.last.loc.line
           return false if distance > 1
-          return false unless comment_line_only?(preceding_comment)
+          return false unless comment_line_only?(preceding_comments.last)
 
           # As long as there's at least one comment line that isn't an
           # annotation, it's OK.
-          ast_with_comments[node].any? { |comment| !annotation?(comment) }
+          preceding_comments.any? { |comment| !annotation?(comment) }
+        end
+
+        def preceding_comments(node, ast_with_comments)
+          return [] unless node && ast_with_comments
+
+          ast_with_comments[node].select { |c| c.loc.line < node.loc.line }
         end
 
         def comment_line_only?(comment)

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

@@ -110,6 +110,31 @@ module RuboCop
             add_offense(node, :else, MSG)
           end
         end
+
+        def autocorrect(node)
+          return false if autocorrect_forbidden?(node.type.to_s)
+
+          lambda do |corrector|
+            end_pos = if node.loc.end
+                        node.loc.end.begin_pos
+                      else
+                        node.loc.expression.end_pos + 1
+                      end
+            range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                              node.loc.else.begin_pos,
+                                              end_pos)
+            corrector.remove(range)
+          end
+        end
+
+        def autocorrect_forbidden?(type)
+          [type, 'both'].include? missing_else_style
+        end
+
+        def missing_else_style
+          missing_config = config.for_cop('Style/MissingElse')
+          missing_config['Enabled'] ? missing_config['EnforcedStyle'] : nil
+        end
       end
     end
   end

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

@@ -25,11 +25,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if node.loc.keyword.is?('if')
-            cond, body = *node
-          else
-            cond, _else, body = *node
-          end
+          cond, body, _else = if_node_parts(node)
 
           oneline =
             "#{body.loc.expression.source} #{node.loc.keyword.source} " +

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

@@ -157,11 +157,7 @@ module RuboCop
           return if ternary_op?(node)
           return if modifier_if?(node)
 
-          case node.loc.keyword.source
-          when 'if', 'elsif' then _condition, body, else_clause = *node
-          when 'unless'      then _condition, else_clause, body = *node
-          else                    _condition, body = *node
-          end
+          _condition, body, else_clause = if_node_parts(node)
 
           check_if(node, body, else_clause, base.loc) if body
         end

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

@@ -121,15 +121,17 @@ module RuboCop
           _, method_name, *args = *send_node
           if operator?(method_name) && args.any?
             args.first.loc.expression
-          elsif send_node.loc.dot &&
-                send_node.loc.selector &&
-                send_node.loc.dot.line == send_node.loc.selector.line
-            send_node.loc.dot.join(send_node.loc.selector)
-          elsif send_node.loc.selector
-            send_node.loc.selector
-          elsif send_node.loc.dot.line == send_node.loc.begin.line
-            # lambda.(args)
-            send_node.loc.dot.join(send_node.loc.begin)
+          else
+            dot = send_node.loc.dot
+            selector = send_node.loc.selector
+            if dot && selector && dot.line == selector.line
+              dot.join(selector)
+            elsif selector
+              selector
+            elsif dot.line == send_node.loc.begin.line
+              # lambda.(args)
+              dot.join(send_node.loc.begin)
+            end
           end
         end
 
@@ -173,7 +175,7 @@ module RuboCop
         end
 
         def not_for_this_cop?(node)
-          node.each_ancestor.find do |ancestor|
+          node.each_ancestor.any? do |ancestor|
             grouped_expression?(ancestor) ||
               inside_arg_list_parentheses?(node, ancestor)
           end

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

@@ -50,7 +50,7 @@ module RuboCop
 
         def on_for(node)
           _, _, body = *node
-          return unless ends_with_condition?(body)
+          return unless body && ends_with_condition?(body)
 
           add_offense(node, :keyword, MSG)
         end

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

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for simple usages of parallel assignment.
+      # This will only complain when the number of variables
+      # being assigned matched the number of assigning variables.
+      #
+      # @example
+      #   # bad
+      #   a, b, c = 1, 2, 3
+      #   a, b, c = [1, 2, 3]
+      #
+      #   # good
+      #   one, two = *foo
+      #   a, b = foo()
+      #   a, b = b, a
+      #
+      #   a = 1
+      #   b = 2
+      #   c = 3
+      class ParallelAssignment < Cop
+        include AutocorrectAlignment
+        include IfNode
+
+        MSG = 'Do not use parallel assignment.'
+
+        def on_masgn(node)
+          left, right = *node
+          left_elements = *left
+          right_elements = [*right].compact # edge case for one constant
+
+          # only complain when the number of variables matches
+          return if left_elements.size != right_elements.size
+
+          # account for edge cases using one variable with a comma
+          return if left_elements.size == 1
+
+          # allow mass assignment as the return of a method call
+          return if right.block_type? || right.send_type?
+
+          # allow mass assignment when using splat
+          return if (left_elements + right_elements).any?(&:splat_type?)
+
+          # a, b = b, a
+          return if swapping_variables?(left_elements, right_elements)
+
+          add_offense(node, :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            assignment_corrector =
+              if modifier_statement?(node.parent)
+                ModifierCorrector.new(node, configured_indentation_width)
+              elsif rescue_modifier?(node.parent)
+                RescueCorrector.new(node, configured_indentation_width)
+              else
+                GenericCorrector.new(node, configured_indentation_width)
+              end
+
+            corrector.replace(assignment_corrector.correction_range,
+                              assignment_corrector.correction)
+          end
+        end
+
+        private
+
+        def swapping_variables?(left_elements, right_elements)
+          left_elements.any? do |le|
+            right_elements.any? do |re|
+              re.loc.expression.is?(le.loc.expression.source)
+            end
+          end
+        end
+
+        def modifier_statement?(node)
+          node &&
+            ((node.if_type? && modifier_if?(node)) ||
+            ((node.while_type? || node.until_type?) && modifier_while?(node)))
+        end
+
+        def modifier_while?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(while until).include?(node.loc.keyword.source) &&
+            node.loc.respond_to?(:end) && node.loc.end.nil?
+        end
+
+        def rescue_modifier?(node)
+          node &&
+            node.rescue_type? &&
+            (node.parent.nil? || !node.parent.kwbegin_type?)
+        end
+
+        # An internal class for correcting parallel assignment
+        class GenericCorrector
+          attr_reader :correction, :correction_range
+
+          def initialize(node, indentation_width)
+            @node = node
+            @indentation_width = indentation_width
+          end
+
+          def correction
+            "#{assignment.join("\n#{indent}")}"
+          end
+
+          def correction_range
+            @node.loc.expression
+          end
+
+          protected
+
+          def space_offset
+            @node.loc.expression.column
+          end
+
+          def indent
+            ' ' * space_offset
+          end
+
+          attr_reader :indentation_width
+
+          def assignment
+            left, right = *@node
+            l_vars = extract_sources(left)
+            r_vars = extract_sources(right)
+            groups = l_vars.zip(r_vars)
+            groups.map { |pair| pair.join(' = ') }
+          end
+
+          private
+
+          def extract_sources(node)
+            node.children.map { |child| child.loc.expression.source }
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # protected by rescue
+        class RescueCorrector < GenericCorrector
+          def correction
+            _node, rescue_clause = *@node.parent
+            _, _, rescue_result = *rescue_clause
+
+            "begin\n" <<
+              indent << assignment.join("\n#{indent}") <<
+              "\nrescue\n" <<
+              indent << rescue_result.loc.expression.source <<
+              "\nend"
+          end
+
+          def correction_range
+            @node.parent.loc.expression
+          end
+
+          protected
+
+          def space_offset
+            offset = super
+            offset + indentation_width
+          end
+        end
+
+        # An internal class for correcting parallel assignment
+        # guarded by if, unless, while, or until
+        class ModifierCorrector < GenericCorrector
+          def correction
+            parent = @node.parent
+
+            modifier_range =
+              Parser::Source::Range.new(parent.loc.expression.source_buffer,
+                                        parent.loc.keyword.begin_pos,
+                                        parent.loc.expression.end_pos)
+
+            "#{modifier_range.source}\n" <<
+              indent << assignment.join("\n#{indent}") <<
+              "\nend"
+          end
+
+          def correction_range
+            @node.parent.loc.expression
+          end
+
+          protected
+
+          def space_offset
+            offset = super
+            offset + indentation_width
+          end
+        end
+      end
+    end
+  end
+end