rubocop 0.15.0 → 0.16.0

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for checking if nodes.
+    module IfNode
+      def modifier_if?(node)
+        node.loc.end.nil?
+      end
+
+      def ternary_op?(node)
+        node.loc.respond_to?(:question)
+      end
+
+      def elsif?(node)
+        node.loc.respond_to?(:keyword) && node.loc.keyword &&
+          node.loc.keyword.is?('elsif')
+      end
+
+      def if_else?(node)
+        node.loc.respond_to?(:else) && node.loc.else
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module Rubocop
           # We won't check modifier or ternary conditionals.
           if node.loc.expression.source =~ /\A(if|unless)\b/
             if offending_line(node)
-              convention(node, :expression, error_message)
+              add_offence(node, :expression, error_message)
             end
           end
         end

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

@@ -13,11 +13,19 @@ module Rubocop
       #  end
       # end
       class IndentationWidth < Cop
+        include CheckMethods
+        include CheckAssignment
+        include IfNode
+
         CORRECT_INDENTATION = 2
-        MSG = "Use #{CORRECT_INDENTATION} (not %d) spaces for indentation."
+
+        def on_begin(node)
+          check_consistent(node)
+        end
 
         def on_kwbegin(node)
-          node.children.each { |c| check_indentation(node.loc.end, c) }
+          check_indentation(node.loc.end, node.children.first)
+          check_consistent(node)
         end
 
         def on_block(node)
@@ -37,13 +45,7 @@ module Rubocop
           members.each { |m| check_indentation(node.loc.keyword, m) }
         end
 
-        def on_def(node)
-          _method_name, _args, body = *node
-          check_indentation(node.loc.keyword, body)
-        end
-
-        def on_defs(node)
-          _scope, _method_name, _args, body = *node
+        def check(node, _method_name, _args, body)
           check_indentation(node.loc.keyword, body)
         end
 
@@ -54,7 +56,9 @@ module Rubocop
 
         def on_while(node)
           _condition, body = *node
-          check_indentation(node.loc.keyword, body)
+          if node.loc.keyword.begin_pos == node.loc.expression.begin_pos
+            check_indentation(node.loc.keyword, body)
+          end
         end
 
         alias_method :on_until, :on_while
@@ -76,7 +80,8 @@ module Rubocop
           end
         end
 
-        def on_if(node)
+        def on_if(node, offset = 0)
+          return if ignored_node?(node)
           return if ternary_op?(node)
           return if modifier_if?(node)
 
@@ -86,60 +91,89 @@ module Rubocop
           else               _condition, body = *node
           end
 
-          check_if(node, body, else_clause) if body
+          check_if(node, body, else_clause, offset) if body
         end
 
         private
 
-        def check_if(node, body, else_clause)
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # 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)
+            ignore_node(rhs)
+          end
+        end
+
+        def check_if(node, body, else_clause, offset)
           return if ternary_op?(node)
           # Don't check if expression is on same line as "then" keyword.
-          check_indentation(node.loc.keyword, body)
+          check_indentation(node.loc.keyword, body, offset)
           if else_clause
             if elsif?(else_clause)
               _condition, inner_body, inner_else_clause = *else_clause
-              check_if(else_clause, inner_body, inner_else_clause)
+              check_if(else_clause, inner_body, inner_else_clause, offset)
             else
-              check_indentation(node.loc.keyword, else_clause)
+              check_indentation(node.loc.else, else_clause)
             end
           end
         end
 
-        def modifier_if?(node)
-          node.loc.end.nil?
-        end
-
-        def ternary_op?(node)
-          node.loc.respond_to?(:question)
-        end
-
-        def elsif?(node)
-          node.loc.respond_to?(:keyword) && node.loc.keyword &&
-            node.loc.keyword.is?('elsif')
-        end
-
-        def check_indentation(base_loc, body_node)
+        def check_indentation(base_loc, body_node, offset = 0)
           return unless body_node
           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.
           # For example lines like "else do_something".
           first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
           return unless body_node.loc.column == first_char_pos_on_line
 
           indentation = body_node.loc.column - base_loc.column
-          if indentation != CORRECT_INDENTATION
-            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
-            convention(nil,
-                       Parser::Source::Range.new(expr.source_buffer,
-                                                 begin_pos, end_pos),
-                       sprintf(MSG, indentation))
+          return if indentation == CORRECT_INDENTATION ||
+              indentation + offset == CORRECT_INDENTATION
+
+          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
+
+          add_offence(nil,
+                      Parser::Source::Range.new(expr.source_buffer,
+                                                begin_pos, end_pos),
+                      sprintf("Use #{CORRECT_INDENTATION} (not %d) spaces " +
+                              'for indentation.', indentation))
+        end
+
+        def starts_with_access_modifier?(body_node)
+          body_node.type == :begin &&
+            AccessModifierIndentation.modifier_node?(body_node.children.first)
+        end
+
+        def check_consistent(node)
+          children_to_check = node.children.reject do |child|
+            # Don't check nodes that have special indentation and will be
+            # checked by the AccessModifierIndentation cop.
+            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),
+                          'Inconsistent indentation detected.')
+            end
           end
         end
       end

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

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

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

@@ -13,6 +13,8 @@ module Rubocop
       #  # good
       #  lambda.call(x, y)
       class LambdaCall < Cop
+        include ConfigurableEnforcedStyle
+
         def on_send(node)
           _receiver, selector, = *node
 
@@ -21,9 +23,9 @@ module Rubocop
 
           if style == :call && node.loc.selector.nil?
             # lambda.() does not have a selector
-            convention(node, :expression)
+            add_offence(node, :expression)
           elsif style == :braces && node.loc.selector
-            convention(node, :expression)
+            add_offence(node, :expression)
           end
         end
 
@@ -48,16 +50,6 @@ module Rubocop
             'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
           end
         end
-
-        private
-
-        def style
-          case cop_config['EnforcedStyle']
-          when 'call' then :call
-          when 'braces' then :braces
-          else fail 'Unknown style selected!'
-          end
-        end
       end
     end
   end

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
-                convention(comment, :expression)
+                add_offence(comment, :expression)
               end
             end
           end

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

@@ -6,17 +6,21 @@ module Rubocop
       # This cop checks the length of lines in the source code.
       # The maximum length is configurable.
       class LineLength < Cop
+        include ConfigurableMax
+
         MSG = 'Line is too long. [%d/%d]'
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             if line.length > max
               message = sprintf(MSG, line.length, max)
-              convention(nil,
-                         source_range(processed_source.buffer,
-                                      processed_source[0...index], max,
-                                      line.length - max),
-                         message)
+              add_offence(nil,
+                          source_range(processed_source.buffer,
+                                       processed_source[0...index], max,
+                                       line.length - max),
+                          message) do
+                self.max = line.length
+              end
             end
           end
         end

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]/
 
-          convention(node, :begin) if args.empty? && node.loc.begin
+          add_offence(node, :begin) if args.empty? && node.loc.begin
         end
 
         def autocorrect(node)

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

@@ -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)
-            convention(nil, range)
+            add_offence(nil, range)
           end
         end
       end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for parentheses around the arguments in method
+      # definitions. Both instance and class/singleton methods are checked.
+      class MethodDefParentheses < Cop
+        include CheckMethods
+        include ConfigurableEnforcedStyle
+
+        def check(node, _method_name, args, _body)
+          if style == :require_parentheses &&
+              arguments?(args) &&
+              !parentheses?(args)
+            add_offence(node,
+                        args.loc.expression,
+                        'Use def with parentheses when there are parameters.')
+          elsif style == :require_no_parentheses && parentheses?(args)
+            add_offence(args,
+                        :expression,
+                        'Use def without parentheses.')
+          end
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            if style == :require_parentheses
+              corrector.insert_after(node.children[1].loc.expression, ')')
+              expression = node.loc.expression
+              replacement = expression.source.sub(/(def\s+\S+)\s+/, '\1(')
+              corrector.replace(expression, replacement)
+            elsif style == :require_no_parentheses
+              corrector.replace(node.loc.begin, ' ')
+              corrector.remove(node.loc.end)
+            end
+          end
+        end
+
+        private
+
+        def arguments?(args)
+          args.children.size > 0
+        end
+
+        def parentheses?(args)
+          args.loc.begin
+        end
+      end
+    end
+  end
+end

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

@@ -7,34 +7,21 @@ module Rubocop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop
-        MSG = 'Method has too many lines. [%d/%d]'
+        include CheckMethods
+        include CodeLength
 
-        def on_def(node)
-          check(node)
-        end
-
-        def on_defs(node)
-          check(node)
-        end
-
-        def max_length
-          cop_config['Max']
-        end
+        private
 
-        def count_comments?
-          cop_config['CountComments']
+        def message
+          'Method has too many lines. [%d/%d]'
         end
 
-        private
+        def code_length(node)
+          lines = node.loc.expression.source.lines.to_a[1..-2] || []
 
-        def check(node)
-          method_length = Util.source_length(node.loc.expression.source,
-                                             count_comments?)
+          lines.reject! { |line| irrelevant_line(line) }
 
-          if method_length > max_length
-            message = sprintf(MSG, method_length, max_length)
-            convention(node, :keyword, message)
-          end
+          lines.size
         end
       end
     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|
-              convention(body_node, :expression) if body_node == TARGET_NODE
+              add_offence(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)
-                convention(nil, range)
+                add_offence(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_if_then.rb

@@ -29,13 +29,23 @@ module Rubocop
                        end
           right_after_cond =
             Parser::Source::Range.new(next_thing.source_buffer,
-                                      condition.loc.expression.end.end_pos,
+                                      end_position(condition),
                                       next_thing.begin_pos)
           if right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
             node.loc.expression.begin.line
           end
         end
 
+        def end_position(conditional_node)
+          node = if conditional_node.type == :match_current_line
+                   conditional_node.children.first
+                 else
+                   conditional_node
+                 end
+
+          node.loc.expression.end.end_pos
+        end
+
         def error_message
           'Never use then for multi-line if/unless.'
         end