rubocop 0.31.0 → 0.35.0

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

@@ -25,32 +25,55 @@ module RuboCop
         def on_block(node)
           return if ignored_node?(node)
 
-          if proper_block_style?(node)
-            correct_style_detected
-          else
-            add_offense(node, :begin) { opposite_style_detected }
-          end
+          return if proper_block_style?(node)
+
+          add_offense(node, :begin)
         end
 
         private
 
-        def message(node)
+        def line_count_based_message(node)
+          block_length = Util.block_length(node)
+
+          if block_length > 0
+            'Avoid using `{...}` for multi-line blocks.'
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def semantic_message(node)
           block_begin = node.loc.begin.source
+
+          if block_begin == '{'
+            'Prefer `do...end` over `{...}` for procedural blocks.'
+          else
+            'Prefer `{...}` over `do...end` for functional blocks.'
+          end
+        end
+
+        def braces_for_chaining_message(node)
           block_length = Util.block_length(node)
 
-          case style
-          when :line_count_based
-            if block_length > 0
-              'Avoid using `{...}` for multi-line blocks.'
+          if block_length > 0
+            if return_value_chaining?(node)
+              'Prefer `{...}` over `do...end` for multi-line chained blocks.'
             else
-              'Prefer `{...}` over `do...end` for single-line blocks.'
+              'Prefer `do...end` for multi-line blocks without chaining.'
             end
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def message(node)
+          case style
+          when :line_count_based
+            line_count_based_message(node)
           when :semantic
-            if block_begin == '{'
-              'Prefer `do...end` over `{...}` for procedural blocks.'
-            else
-              'Prefer `{...}` over `do...end` for functional blocks.'
-            end
+            semantic_message(node)
+          when :braces_for_chaining
+            braces_for_chaining_message(node)
           end
         end
 
@@ -59,11 +82,8 @@ module RuboCop
             b = node.loc.begin
             e = node.loc.end
             if b.is?('{')
-              # If the left brace is not preceded by a whitespace character,
-              # then we need a space before `do` to get valid Ruby code.
-              if b.source_buffer.source[b.begin_pos - 1, 1] =~ /\S/
-                corrector.insert_before(b, ' ')
-              end
+              corrector.insert_before(b, ' ') unless whitespace_before?(b)
+              corrector.insert_before(e, ' ') unless whitespace_before?(e)
               corrector.replace(b, 'do')
               corrector.replace(e, 'end')
             else
@@ -73,6 +93,10 @@ module RuboCop
           end
         end
 
+        def whitespace_before?(node)
+          node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
+        end
+
         def get_block(node)
           case node.type
           when :block
@@ -89,6 +113,8 @@ module RuboCop
             line_count_based_block_style?(node)
           when :semantic
             semantic_block_style?(node)
+          when :braces_for_chaining
+            braces_for_chaining_style?(node)
           end
         end
 
@@ -116,6 +142,21 @@ module RuboCop
           end
         end
 
+        def braces_for_chaining_style?(node)
+          block_length = Util.block_length(node)
+          block_begin = node.loc.begin.source
+
+          if block_length > 0
+            block_begin == (return_value_chaining?(node) ? '{' : 'do')
+          else
+            block_begin == '{'
+          end
+        end
+
+        def return_value_chaining?(node)
+          node.parent && node.parent.send_type? && node.parent.loc.dot
+        end
+
         def extract_method_name_from_block(block)
           node, _args, _body = *block
           _receiver, method_name, *_args = *node
@@ -147,15 +188,15 @@ module RuboCop
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            Util::ASGN_NODES.include?(node.parent.type) ||
-              node.parent.send_type?
+            node.parent.assignment? || node.parent.send_type?
           end
         end
 
         def return_value_of_scope?(node)
           return unless node.parent
 
-          conditional?(node.parent) || node.parent.children.last == node
+          conditional?(node.parent) || array_or_range?(node.parent) ||
+            node.parent.children.last == node
         end
 
         def procedural_methods
@@ -173,6 +214,10 @@ module RuboCop
         def conditional?(node)
           node.if_type? || node.or_type? || node.and_type?
         end
+
+        def array_or_range?(node)
+          node.array_type? || node.irange_type? || node.erange_type?
+        end
       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.'
 
@@ -14,7 +15,7 @@ module RuboCop
           _receiver, method_name, *args = *node
 
           # Discard attr writer methods.
-          return if method_name.to_s.end_with?('=')
+          return if node.asgn_method_call?
           # Discard operator methods.
           return if operator?(method_name)
 
@@ -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/collection_methods.rb

@@ -10,6 +10,8 @@ module RuboCop
       # Enumerable or not (static analysis limitation), so this cop
       # can yield some false positives.
       class CollectionMethods < Cop
+        include MethodPreference
+
         MSG = 'Prefer `%s` over `%s`.'
 
         def on_block(node)
@@ -44,26 +46,6 @@ module RuboCop
                              method_name)
                      )
         end
-
-        def preferred_method(method)
-          preferred_methods[method.to_sym]
-        end
-
-        def preferred_methods
-          @preferred_methods ||=
-            begin
-              # Make sure default configuration 'foo' => 'bar' is removed from
-              # the total configuration if there is a 'bar' => 'foo' override.
-              default = default_cop_config['PreferredMethods']
-              merged = cop_config['PreferredMethods']
-              overrides = merged.values - default.values
-              merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
-            end
-        end
-
-        def default_cop_config
-          ConfigLoader.default_configuration[cop_name]
-        end
       end
     end
   end

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

@@ -47,7 +47,7 @@ module RuboCop
         def check_backtick_literal(node)
           return if style == :backticks && !contains_disallowed_backtick?(node)
           return if style == :mixed &&
-                    single_line?(node) &&
+                    node.single_line? &&
                     !contains_disallowed_backtick?(node)
 
           add_offense(node, :expression, MSG_USE_PERCENT_X)
@@ -56,7 +56,7 @@ module RuboCop
         def check_percent_x_literal(node)
           return if style == :backticks && contains_disallowed_backtick?(node)
           return if style == :percent_x
-          return if style == :mixed && multi_line?(node)
+          return if style == :mixed && node.multiline?
           return if style == :mixed && contains_disallowed_backtick?(node)
 
           add_offense(node, :expression, MSG_USE_BACKTICKS)
@@ -87,14 +87,6 @@ module RuboCop
           node.loc.begin.source == '`'
         end
 
-        def single_line?(node)
-          !multi_line?(node)
-        end
-
-        def multi_line?(node)
-          block_length(node) > 1
-        end
-
         def preferred_delimiters
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%x'].split(//)

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

@@ -8,30 +8,51 @@ 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|
+          processed_source.comments.each_with_index do |comment, ix|
+            next unless first_comment_line?(processed_source.comments, ix)
+
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
             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 first_comment_line?(comments, ix)
+          ix == 0 || comments[ix - 1].loc.line < comments[ix].loc.line - 1
+        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|
-            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/copyright.rb

@@ -68,10 +68,12 @@ module RuboCop
         end
 
         def autocorrect(token)
-          fail 'An AutocorrectNotice must be defined in ' \
+          fail Warning, 'An AutocorrectNotice must be defined in ' \
             'your RuboCop config' if autocorrect_notice.empty?
-          fail "AutocorrectNotice '#{autocorrect_notice}' must match " \
-            "Notice /#{notice}/" unless autocorrect_notice =~ Regexp.new(notice)
+          regex = Regexp.new(notice)
+          fail Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+            "match Notice /#{notice}/" unless autocorrect_notice =~ regex
+
           lambda do |corrector|
             if token.nil?
               range = Parser::Source::Range.new('', 0, 0)

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for missing top-level documentation of
       # classes and modules. Classes with no body are exempt from the
       # check and so are namespace modules - modules that have nothing in
-      # their bodies except classes or other other modules.
+      # their bodies except classes or other modules.
       #
       # The documentation requirement is annulled if the class or module has
       # a "#:nodoc:" comment next to it. Likewise, "#:nodoc: all" does the
@@ -47,34 +47,43 @@ module RuboCop
           end
         end
 
+        # 'Const = Class.new' or 'Const = Module.new' are module definitions
+        mod_new = '(send (const nil {:Class :Module}) :new ...)'
+        def_node_matcher :module_definition?,
+                         "{class
+                           module
+                           (casgn _ _ {#{mod_new} (block #{mod_new} ...)})}"
+
         def namespace?(body_node)
           return false unless body_node
 
           case body_node.type
           when :begin
-            body_node.children.all? do |node|
-              [:class, :module].include?(node.type)
-            end
-          when :class, :module
-            true
+            body_node.children.all? { |node| module_definition?(node) }
           else
-            false
+            module_definition?(body_node)
           end
         end
 
         # 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/dot_position.rb

@@ -46,6 +46,12 @@ module RuboCop
 
           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
+
           case style
           when :leading then dot_line == selector_line
           when :trailing then dot_line != selector_line

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

@@ -22,22 +22,11 @@ module RuboCop
       class DoubleNegation < Cop
         MSG = 'Avoid the use of double negation (`!!`).'
 
-        def on_send(node)
-          return unless not_node?(node)
-
-          receiver, _method_name, *_args = *node
-
-          add_offense(node, :selector) if not_node?(receiver)
-        end
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
-        private
-
-        def not_node?(node)
-          _receiver, method_name, *args = *node
-
-          # ! does not take any arguments
-          args.empty? && method_name == :! &&
-            node.loc.selector.is?('!')
+        def on_send(node)
+          return unless double_negative?(node) && node.loc.selector.is?('!')
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -7,6 +7,9 @@ module RuboCop
       # returned at the end and so could be replace by each_with_object without
       # the need to return the object at the end.
       #
+      # However, we can't replace with each_with_object if the accumulator
+      # parameter is assigned to within the block.
+      #
       # @example
       #   # bad
       #   [1, 2].inject({}) { |a, e| a[e] = e; a }
@@ -23,16 +26,26 @@ module RuboCop
           # filter out super and zsuper nodes
           return unless method.type == :send
 
-          _, method_name, method_args = *method
+          _, method_name, method_arg = *method
 
           return unless METHODS.include? method_name
-          return if method_args && method_args.type == :sym
+          return if method_arg && BASIC_LITERALS.include?(method_arg.type)
 
           return_value = return_value(body)
           return unless return_value
 
           return unless first_argument_returned?(args, return_value)
 
+          # if the accumulator parameter is assigned to in the block,
+          # then we can't convert to each_with_object
+          first_arg, = *args
+          accumulator_var, = *first_arg
+          return if 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
 
@@ -47,8 +60,8 @@ module RuboCop
 
         def first_argument_returned?(args, return_value)
           first_arg, = *args
-          accumulator_var = *first_arg
-          return_var = *return_value
+          accumulator_var, = *first_arg
+          return_var, = *return_value
 
           accumulator_var == return_var
         end

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

@@ -8,6 +8,7 @@ module RuboCop
       # are special cases when they should follow the same rules as the
       # alignment of end.
       class ElseAlignment < Cop
+        include EndKeywordAlignment
         include AutocorrectAlignment
         include CheckAssignment
 
@@ -86,7 +87,7 @@ module RuboCop
 
           end_config = config.for_cop('Lint/EndAlignment')
           style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
-          base = style == 'variable' ? node : rhs
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           return if rhs.type != :if
 

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