rubocop 0.18.1 → 0.19.0

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

@@ -14,6 +14,8 @@ module Rubocop
       #   end
       # end
       class IndentationConsistency < Cop
+        include AutocorrectAlignment
+
         MSG = 'Inconsistent indentation detected.'
 
         def on_begin(node)
@@ -33,17 +35,7 @@ module Rubocop
             AccessModifierIndentation.modifier_node?(child)
           end
 
-          children_to_check.map(&:loc).each_cons(2) do |child1, child2|
-            if child2.line > child1.line && child2.column != child1.column
-              expr = child2.expression
-              indentation = expr.source_line =~ /\S/
-              end_pos = expr.begin_pos
-              begin_pos = end_pos - indentation
-              add_offence(nil,
-                          Parser::Source::Range.new(expr.source_buffer,
-                                                    begin_pos, end_pos))
-            end
-          end
+          check_alignment(children_to_check)
         end
       end
     end

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

@@ -13,6 +13,7 @@ module Rubocop
       #  end
       # end
       class IndentationWidth < Cop
+        include AutocorrectAlignment
         include CheckMethods
         include CheckAssignment
         include IfNode
@@ -49,10 +50,10 @@ module Rubocop
           check_indentation(node.loc.keyword, body)
         end
 
-        def on_while(node)
+        def on_while(node, base = node)
           _condition, body = *node
           if node.loc.keyword.begin_pos == node.loc.expression.begin_pos
-            check_indentation(node.loc.keyword, body)
+            check_indentation(base.loc, body)
           end
         end
 
@@ -75,7 +76,7 @@ module Rubocop
           end
         end
 
-        def on_if(node, offset = 0)
+        def on_if(node, base = node)
           return if ignored_node?(node)
           return if ternary_op?(node)
           return if modifier_if?(node)
@@ -86,7 +87,7 @@ module Rubocop
           else               _condition, body = *node
           end
 
-          check_if(node, body, else_clause, offset) if body
+          check_if(node, body, else_clause, base.loc) if body
         end
 
         private
@@ -97,29 +98,46 @@ module Rubocop
           # we check its indentation.
           rhs = first_part_of_call_chain(rhs)
 
-          if rhs && rhs.type == :if
-            on_if(rhs, rhs.loc.column - node.loc.column)
+          if rhs
+            end_alignment_config = config.for_cop('EndAlignment')
+            style = if end_alignment_config['Enabled']
+                      end_alignment_config['AlignWith']
+                    else
+                      'keyword'
+                    end
+            base = style == 'variable' ? node : rhs
+
+            case rhs.type
+            when :if            then on_if(rhs, base)
+            when :while, :until then on_while(rhs, base)
+            else                     return
+            end
+
             ignore_node(rhs)
           end
         end
 
-        def check_if(node, body, else_clause, offset)
+        def check_if(node, body, else_clause, base_loc)
           return if ternary_op?(node)
-          # Don't check if expression is on same line as "then" keyword.
-          check_indentation(node.loc.keyword, body, offset)
+
+          check_indentation(base_loc, body)
+
           if else_clause
             if elsif?(else_clause)
               _condition, inner_body, inner_else_clause = *else_clause
-              check_if(else_clause, inner_body, inner_else_clause, offset)
+              check_if(else_clause, inner_body, inner_else_clause, base_loc)
             else
               check_indentation(node.loc.else, else_clause)
             end
           end
         end
 
-        def check_indentation(base_loc, body_node, offset = 0)
+        def check_indentation(base_loc, body_node)
           return unless body_node
+
+          # Don't check if expression is on same line as "then" keyword, etc.
           return if body_node.loc.line == base_loc.line
+
           return if starts_with_access_modifier?(body_node)
 
           # Don't check indentation if the line doesn't start with the body.
@@ -128,22 +146,25 @@ module Rubocop
           return unless body_node.loc.column == first_char_pos_on_line
 
           indentation = body_node.loc.column - base_loc.column
-          return if indentation == CORRECT_INDENTATION ||
-              indentation + offset == CORRECT_INDENTATION
+          @column_delta = CORRECT_INDENTATION - indentation
+          return if @column_delta == 0
+
+          # This cop only auto-corrects the first statement in a def body, for
+          # example.
+          body_node = body_node.children.first if body_node.type == :begin
 
           expr = body_node.loc.expression
-          begin_pos, end_pos =
-            if indentation >= 0
-              [expr.begin_pos - indentation, expr.begin_pos]
-            else
-              [expr.begin_pos, expr.begin_pos - indentation]
-            end
+          pos = if indentation >= 0
+                  (expr.begin_pos - indentation)..expr.begin_pos
+                else
+                  expr.begin_pos..(expr.begin_pos - indentation)
+                end
 
-          add_offence(nil,
+          add_offense(body_node,
                       Parser::Source::Range.new(expr.source_buffer,
-                                                begin_pos, end_pos),
-                      sprintf("Use #{CORRECT_INDENTATION} (not %d) spaces " +
-                              'for indentation.', indentation))
+                                                pos.begin, pos.end),
+                      format("Use #{CORRECT_INDENTATION} (not %d) spaces " \
+                             'for indentation.', indentation))
         end
 
         def starts_with_access_modifier?(body_node)

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

@@ -24,9 +24,9 @@ module Rubocop
             lambda_length = lambda_length(node)
 
             if selector != '->' && lambda_length == 0
-              add_offence(block_method, :expression, SINGLE_MSG)
+              add_offense(block_method, :expression, SINGLE_MSG)
             elsif selector == '->' && lambda_length > 0
-              add_offence(block_method, :expression, MULTI_MSG)
+              add_offense(block_method, :expression, MULTI_MSG)
             end
           end
         end

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

@@ -21,8 +21,8 @@ module Rubocop
           # we care only about `call` methods
           return unless selector == :call
 
-          if offence?(node)
-            add_offence(node, :expression) { opposite_style_detected }
+          if offense?(node)
+            add_offense(node, :expression) { opposite_style_detected }
           else
             correct_style_detected
           end
@@ -30,7 +30,7 @@ module Rubocop
 
         private
 
-        def offence?(node)
+        def offense?(node)
           # lambda.() does not have a selector
           style == :call && node.loc.selector.nil? ||
             style == :braces && node.loc.selector

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

@@ -14,7 +14,7 @@ module Rubocop
           processed_source.comments.each do |comment|
             if comment.text =~ /^#+[^#\s:+-]/
               unless comment.text.start_with?('#!') && comment.loc.line == 1
-                add_offence(comment, :expression)
+                add_offense(comment, :expression)
               end
             end
           end

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

@@ -20,7 +20,7 @@ module Rubocop
         MSG = 'Use \\ instead of + to concatenate those strings.'
 
         def on_send(node)
-          add_offence(node, :selector) if offending_node?(node)
+          add_offense(node, :selector) if offending_node?(node)
         end
 
         def autocorrect(node)
@@ -38,9 +38,9 @@ module Rubocop
           # TODO: Report Emacs bug.
           return false unless :+ == method
 
-          return false unless receiver.type == :str
+          return false unless string_type?(receiver.type)
 
-          return false unless arg.type == :str
+          return false unless string_type?(arg.type)
 
           plus_at_line_end?(node.loc.expression.source)
         end
@@ -49,6 +49,10 @@ module Rubocop
           # check if the first line of the expression ends with a +
           expression =~ /.+\+\s*$/
         end
+
+        def string_type?(node_type)
+          [:str, :dstr].include?(node_type)
+        end
       end
     end
   end

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

@@ -13,8 +13,8 @@ module Rubocop
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             if line.length > max
-              message = sprintf(MSG, line.length, max)
-              add_offence(nil,
+              message = format(MSG, line.length, max)
+              add_offense(nil,
                           source_range(processed_source.buffer,
                                        processed_source[0...index], max,
                                        line.length - max),

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

@@ -13,7 +13,7 @@ module Rubocop
           # methods starting with a capital letter should be skipped
           return if method_name =~ /\A[A-Z]/
 
-          add_offence(node, :begin) if args.empty? && node.loc.begin
+          add_offense(node, :begin) if args.empty? && node.loc.begin
         end
 
         def autocorrect(node)
@@ -22,7 +22,7 @@ module Rubocop
               [EmptyLiteral::HASH_NODE,
                EmptyLiteral::ARRAY_NODE,
                EmptyLiteral::STR_NODE].include?(node)
-            fail CorrectionNotPossible
+            return
           end
           @corrections << lambda do |corrector|
             corrector.remove(node.loc.begin)

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

@@ -20,7 +20,7 @@ module Rubocop
           # If the method that is chained on the do...end block is itself a
           # method with a block, we allow it. It's pretty safe to assume that
           # these calls are not missed by anyone reading code. We also want to
-          # avoid double reporting of offences checked by the
+          # avoid double reporting of offenses checked by the
           # MultilineBlockChain cop.
           ignore_node(method)
         end
@@ -32,7 +32,7 @@ module Rubocop
             range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
                                               receiver.loc.end.begin_pos,
                                               node.loc.expression.end_pos)
-            add_offence(nil, range)
+            add_offense(nil, range)
           end
         end
       end

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

@@ -12,7 +12,7 @@ module Rubocop
         def check(node, _method_name, args, _body)
           if style == :require_parentheses
             if arguments?(args) && !parentheses?(args)
-              add_offence(node,
+              add_offense(node,
                           args.loc.expression,
                           'Use def with parentheses when there are ' \
                           'parameters.') do
@@ -22,7 +22,7 @@ module Rubocop
               correct_style_detected
             end
           elsif parentheses?(args)
-            add_offence(args, :expression, 'Use def without parentheses.') do
+            add_offense(args, :expression, 'Use def without parentheses.') do
               opposite_style_detected
             end
           else
@@ -33,11 +33,13 @@ module Rubocop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             if style == :require_parentheses
-
-              corrector.insert_after(args_node(node).loc.expression, ')')
-              expression = node.loc.expression
-              replacement = expression.source.sub(/(def\s+\S+)\s+/, '\1(')
-              corrector.replace(expression, replacement)
+              args_expr = args_node(node).loc.expression
+              args_with_space = range_with_surrounding_space(args_expr, :left)
+              just_space = Parser::Source::Range.new(args_expr.source_buffer,
+                                                     args_with_space.begin_pos,
+                                                     args_expr.begin_pos)
+              corrector.replace(just_space, '(')
+              corrector.insert_after(args_expr, ')')
             elsif style == :require_no_parentheses
               corrector.replace(node.loc.begin, ' ')
               corrector.remove(node.loc.end)

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

@@ -22,7 +22,7 @@ module Rubocop
 
           if body && body.type == :begin
             body.children.each do |body_node|
-              add_offence(body_node, :expression) if body_node == TARGET_NODE
+              add_offense(body_node, :expression) if body_node == TARGET_NODE
             end
           end
         end

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

@@ -30,7 +30,7 @@ module Rubocop
                   Parser::Source::Range.new(end_kw_loc.source_buffer,
                                             end_kw_loc.begin_pos,
                                             method.loc.expression.end_pos)
-                add_offence(nil, range)
+                add_offense(nil, range)
                 # Done. If there are more blocks in the chain, they will be
                 # found by subsequent calls to on_block.
                 break

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

@@ -14,7 +14,7 @@ module Rubocop
           # discard non-ternary ops
           return unless loc.respond_to?(:question)
 
-          add_offence(node, :expression) if loc.line != loc.colon.line
+          add_offense(node, :expression) if loc.line != loc.colon.line
         end
       end
     end

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

@@ -6,7 +6,7 @@ module Rubocop
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
         MSG = 'Ternary operators must not be nested. Prefer if/else ' \
-            'constructs instead.'
+              'constructs instead.'
 
         def on_if(node)
           loc = node.loc
@@ -16,7 +16,7 @@ module Rubocop
 
           node.children.each do |child|
             on_node(:if, child) do |c|
-              add_offence(c, :expression) if c.loc.respond_to?(:question)
+              add_offense(c, :expression) if c.loc.respond_to?(:question)
             end
           end
         end

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

@@ -29,7 +29,7 @@ module Rubocop
           if OPS.include?(op)
             _receiver, _method, args = *node
 
-            add_offence(node, :selector) if args == NIL_NODE
+            add_offense(node, :selector) if args == NIL_NODE
           end
         end
       end

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

@@ -13,7 +13,7 @@ module Rubocop
           # not does not take any arguments
           if args.empty? && method_name == :! &&
               node.loc.selector.is?('not')
-            add_offence(node, :selector)
+            add_offense(node, :selector)
           end
         end
       end

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

@@ -7,12 +7,12 @@ module Rubocop
       # of digits in them.
       class NumericLiterals < Cop
         # The parameter is called MinDigits (meaning the minimum number of
-        # digits for which an offence can be registered), but essentially it's
+        # digits for which an offense can be registered), but essentially it's
         # a Max parameter (the maximum number of something that's allowed).
         include ConfigurableMax
 
         MSG = 'Separate every 3 digits in the integer portion of a number ' \
-          'with underscores(_).'
+              'with underscores(_).'
 
         def on_int(node)
           check(node)
@@ -37,10 +37,10 @@ module Rubocop
           if int.size >= min_digits
             case int
             when /^\d+$/
-              add_offence(node, :expression) { self.max = int.size }
+              add_offense(node, :expression) { self.max = int.size }
             when /\d{4}/, /_\d{1,2}_/
-              add_offence(node, :expression) do
-                self.config_to_allow_offences = { 'Enabled' => false }
+              add_offense(node, :expression) do
+                self.config_to_allow_offenses = { 'Enabled' => false }
               end
             end
           end

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

@@ -17,8 +17,8 @@ module Rubocop
 
           if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
               args.children.size == 1 && args != TARGET_ARGS
-            add_offence(args.children[0], :expression,
-                        sprintf(MSG, name))
+            add_offense(args.children[0], :expression,
+                        format(MSG, name))
           end
         end
       end

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

@@ -15,7 +15,7 @@ module Rubocop
         def on_args(node)
           count = args_count(node)
           if count > max_params
-            add_offence(node, :expression, sprintf(MSG, max_params)) do
+            add_offense(node, :expression, format(MSG, max_params)) do
               self.max = count
             end
           end

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

@@ -32,15 +32,16 @@ module Rubocop
             # allow safe assignment
             return if safe_assignment?(cond) && safe_assignment_allowed?
 
-            add_offence(cond, :expression, message(node))
+            add_offense(cond, :expression, message(node))
           end
         end
 
         def parens_required?(node)
-          expr = node.loc.expression.source
-          keyword = node.loc.keyword.source
+          exp = node.loc.expression
+          kw = node.loc.keyword
+          kw_offset = kw.begin_pos - exp.begin_pos
 
-          expr.start_with?("#{keyword}(")
+          exp.source[kw_offset..-1].start_with?(kw.source + '(')
         end
 
         def message(node)