rubocop 0.30.1 → 0.31.0

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

@@ -56,7 +56,8 @@ module RuboCop
 
         def correction(node)
           lambda do |corrector|
-            b, e = node.loc.begin, node.loc.end
+            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.
@@ -82,14 +83,6 @@ module RuboCop
           end
         end
 
-        def parentheses?(send_node)
-          send_node.loc.begin
-        end
-
-        def operator?(method_name)
-          method_name =~ /^\W/
-        end
-
         def proper_block_style?(node)
           case style
           when :line_count_based

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

@@ -40,7 +40,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             indentation = indentation_of_block_start_line(node)
             corrector.insert_before(node.loc.end, "\n" + (' ' * indentation))
           end

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

@@ -48,7 +48,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             if braces?(node)
               right_range = range_with_surrounding_space(node.loc.begin, :right)
               corrector.remove(right_range)

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

@@ -16,7 +16,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             string = node.loc.expression.source[1..-1]
 
             if string.length == 1 # normal character

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

@@ -31,7 +31,7 @@ module RuboCop
         def autocorrect(node)
           _receiver, method_name, *_args = *node
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.selector,
                               method_name == :is_a? ? 'kind_of?' : 'is_a?')
           end

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

@@ -60,9 +60,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.name, 'self')
-          end
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
         end
       end
     end

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

@@ -26,7 +26,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.selector,
                               preferred_method(node.loc.selector.source))
           end

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

@@ -32,9 +32,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.dot, '.')
-          end
+          ->(corrector) { corrector.replace(node.loc.dot, '.') }
         end
       end
     end

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

@@ -101,7 +101,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          fail CorrectionNotPossible if contains_backtick?(node)
+          return if contains_backtick?(node)
 
           if backtick_literal?(node)
             replacement = ['%x', ''].zip(preferred_delimiters).map(&:join)
@@ -109,7 +109,7 @@ module RuboCop
             replacement = %w(` `)
           end
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.begin, replacement.first)
             corrector.replace(node.loc.end, replacement.last)
           end

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

@@ -18,16 +18,23 @@ module RuboCop
                         !correct_annotation?(first_word, colon, space, note)
 
             start = comment.loc.expression.begin_pos + margin.length
-            length = first_word.length + (colon || '').length
+            length = first_word.length + colon.to_s.length + space.to_s.length
             range = Parser::Source::Range.new(processed_source.buffer,
                                               start,
                                               start + length)
-            add_offense(nil, range)
+            add_offense(range, range)
           end
         end
 
         private
 
+        def autocorrect(range)
+          lambda do |corrector|
+            annotation_keyword = range.source.split(/:?\s+/).first
+            corrector.replace(range, annotation_keyword.upcase << ': ')
+          end
+        end
+
         def correct_annotation?(first_word, colon, space, note)
           keyword?(first_word) && (colon && space && note || !colon && !note)
         end

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

@@ -72,7 +72,7 @@ module RuboCop
             'your RuboCop config' if autocorrect_notice.empty?
           fail "AutocorrectNotice '#{autocorrect_notice}' must match " \
             "Notice /#{notice}/" unless autocorrect_notice =~ Regexp.new(notice)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             if token.nil?
               range = Parser::Source::Range.new('', 0, 0)
             else

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

@@ -22,7 +22,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end

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

@@ -22,7 +22,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.replace(node.loc.selector,
                               proper_method_name(node.loc.selector.source))
           end

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

@@ -61,7 +61,7 @@ module RuboCop
             selector = node.loc.begin
           end
 
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.remove(node.loc.dot)
             case style
             when :leading

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

@@ -36,9 +36,7 @@ module RuboCop
 
         def autocorrect(node)
           range = range_with_surrounding_space(node.loc.expression, :left)
-          @corrections << lambda do |corrector|
-            corrector.insert_before(range, "\n")
-          end
+          ->(corrector) { corrector.insert_before(range, "\n") }
         end
       end
     end

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

@@ -36,7 +36,7 @@ module RuboCop
         end
 
         def autocorrect(range)
-          @corrections << ->(corrector) { corrector.remove(range) }
+          ->(corrector) { corrector.remove(range) }
         end
       end
     end

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

@@ -18,7 +18,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             send_line = node.loc.line
             previous_line = processed_source[send_line - 2]
             next_line = processed_source[send_line]

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

@@ -51,16 +51,12 @@ module RuboCop
                    # because the braces are interpreted as a block, so we avoid
                    # the correction. Parentheses around the arguments would
                    # solve the problem, but we let the user add those manually.
-                   if first_arg_in_method_call_without_parentheses?(node)
-                     fail CorrectionNotPossible
-                   end
+                   return if first_arg_in_method_call_without_parentheses?(node)
                    '{}'
                  when STR_NODE
                    "''"
                  end
-          @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression, name)
-          end
+          ->(corrector) { corrector.replace(node.loc.expression, name) }
         end
 
         def first_arg_in_method_call_without_parentheses?(node)

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

@@ -33,7 +33,7 @@ module RuboCop
         def autocorrect(node)
           encoding = cop_config['AutoCorrectEncodingComment']
           if encoding && encoding =~ ENCODING_PATTERN
-            @corrections << lambda do |corrector|
+            lambda do |corrector|
               corrector.replace(node.pos, "#{encoding}\n#{node.pos.source}")
             end
           else

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

@@ -26,10 +26,8 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            correction = "#{base_number(node)}.#{offense_type(node)}?"
-            corrector.replace(node.loc.expression, correction)
-          end
+          correction = "#{base_number(node)}.#{offense_type(node)}?"
+          ->(corrector) { corrector.replace(node.loc.expression, correction) }
         end
 
         private

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

@@ -25,9 +25,7 @@ module RuboCop
         end
 
         def autocorrect(range)
-          @corrections << lambda do |corrector|
-            corrector.remove(range)
-          end
+          ->(corrector) { corrector.remove(range) }
         end
       end
     end

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

@@ -27,6 +27,7 @@ module RuboCop
       class GuardClause < Cop
         include ConfigurableEnforcedStyle
         include IfNode
+        include MinBodyLength
 
         MSG = 'Use a guard clause instead of wrapping the code inside a ' \
               'conditional expression.'
@@ -62,17 +63,6 @@ module RuboCop
 
           add_offense(node, :keyword, MSG)
         end
-
-        def min_body_length?(node)
-          (node.loc.end.line - node.loc.keyword.line) > min_body_length
-        end
-
-        def min_body_length
-          length = cop_config['MinBodyLength'] || 1
-          return length if length.is_a?(Integer) && length > 0
-
-          fail 'MinBodyLength needs to be a positive integer!'
-        end
       end
     end
   end

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

@@ -58,7 +58,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             if style == :hash_rockets || @force_hash_rockets
               autocorrect_hash_rockets(corrector, node)
             elsif style == :ruby19_no_mixed_keys

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

@@ -25,18 +25,23 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if node.loc.keyword.source == 'if'
+          if node.loc.keyword.is?('if')
             cond, body = *node
           else
             cond, _else, body = *node
           end
 
-          @corrections << lambda do |corrector|
-            oneline = "#{body.loc.expression.source} " \
-                      "#{node.loc.keyword.source} " +
-                      cond.loc.expression.source
-            corrector.replace(node.loc.expression, oneline)
+          oneline =
+            "#{body.loc.expression.source} #{node.loc.keyword.source} " +
+            cond.loc.expression.source
+          first_line_comment = processed_source.comments.find do |c|
+            c.loc.line == node.loc.line
           end
+          if first_line_comment
+            oneline << ' ' << first_line_comment.loc.expression.source
+          end
+
+          ->(corrector) { corrector.replace(node.loc.expression, oneline) }
         end
       end
     end

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

@@ -86,7 +86,15 @@ module RuboCop
                                                          args)
 
           _method_name, _args, body = *args.first
-          check_indentation(node.loc.expression, body)
+          def_end_config = config.for_cop('Lint/DefEndAlignment')
+          style = if def_end_config['Enabled']
+                    def_end_config['AlignWith']
+                  else
+                    'start_of_line'
+                  end
+          base = style == 'def' ? args.first : node
+
+          check_indentation(base.loc.expression, body)
           ignore_node(args.first)
         end
 
@@ -232,7 +240,8 @@ module RuboCop
 
         def offending_range(body_node, indentation)
           expr = body_node.loc.expression
-          begin_pos, ind = expr.begin_pos, expr.begin_pos - indentation
+          begin_pos = expr.begin_pos
+          ind = expr.begin_pos - indentation
           pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
           Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
         end

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

@@ -40,14 +40,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
-            condition_node, = *node
-            start_range = node.loc.keyword.begin
-            end_range = if node.loc.begin
-                          node.loc.begin.end
-                        else
-                          condition_node.loc.expression.end
-                        end
+          condition_node, = *node
+          start_range = node.loc.keyword.begin
+          end_range = if node.loc.begin
+                        node.loc.begin.end
+                      else
+                        condition_node.loc.expression.end
+                      end
+          lambda do |corrector|
             corrector.replace(start_range.join(end_range), 'loop do')
           end
         end

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

@@ -37,7 +37,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             if style == :call
               receiver_node, = *node
               expr = node.loc.expression

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

@@ -23,9 +23,7 @@ module RuboCop
           expr = comment.loc.expression
           b = expr.begin_pos
           hash_mark = Parser::Source::Range.new(expr.source_buffer, b, b + 1)
-          @corrections << lambda do |corrector|
-            corrector.insert_after(hash_mark, ' ')
-          end
+          ->(corrector) { corrector.insert_after(hash_mark, ' ') }
         end
       end
     end

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

@@ -35,13 +35,11 @@ module RuboCop
         end
 
         def autocorrect(operator_range)
-          @corrections << lambda do |corrector|
-            # Include any trailing whitespace so we don't create a syntax error.
-            operator_range = range_with_surrounding_space(operator_range,
-                                                          :right, nil,
-                                                          !:with_newline)
-            corrector.replace(operator_range, '\\')
-          end
+          # Include any trailing whitespace so we don't create a syntax error.
+          operator_range = range_with_surrounding_space(operator_range,
+                                                        :right, nil,
+                                                        !:with_newline)
+          ->(corrector) { corrector.replace(operator_range, '\\') }
         end
 
         private

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

@@ -17,14 +17,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          # Bail out if the call is going to be auto-corrected by EmptyLiteral.
-          if config.for_cop('Style/EmptyLiteral')['Enabled'] &&
-             [EmptyLiteral::HASH_NODE,
-              EmptyLiteral::ARRAY_NODE,
-              EmptyLiteral::STR_NODE].include?(node)
-            return
-          end
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)
           end

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

@@ -24,7 +24,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          @corrections << lambda do |corrector|
+          lambda do |corrector|
             if style == :require_parentheses
               args_expr = args_node(node).loc.expression
               args_with_space = range_with_surrounding_space(args_expr, :left)