rubocop 0.15.0 → 0.16.0

data/lib/rubocop/cop/lint/assignment_in_condition.rb

@@ -35,7 +35,7 @@ module Rubocop
 
             # assignment nodes from shorthand ops like ||= don't have operator
             if asgn_node.type != :begin && asgn_node.loc.operator
-              warning(asgn_node, :operator)
+              add_offence(asgn_node, :operator)
             end
           end
         end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -129,13 +129,13 @@ module Rubocop
             match = /\S.*/.match(do_loc.source_line)
             indentation_of_do_line = match.begin(0)
             if end_loc.column != indentation_of_do_line
-              warning(nil,
-                      end_loc,
-                      sprintf(MSG, end_loc.line, end_loc.column,
-                              start_loc.source.lines.to_a.first.chomp,
-                              start_loc.line, start_loc.column,
-                              alt_start_msg(match, start_loc, do_loc,
-                                            indentation_of_do_line)))
+              add_offence(nil,
+                          end_loc,
+                          sprintf(MSG, end_loc.line, end_loc.column,
+                                  start_loc.source.lines.to_a.first.chomp,
+                                  start_loc.line, start_loc.column,
+                                  alt_start_msg(match, start_loc, do_loc,
+                                                indentation_of_do_line)))
             end
           end
         end

data/lib/rubocop/cop/lint/debugger.rb

@@ -27,7 +27,7 @@ module Rubocop
         DEBUGGER_NODES = [DEBUGGER_NODE, PRY_NODE, REMOTE_PRY_NODE]
 
         def on_send(node)
-          warning(node, :selector) if DEBUGGER_NODES.include?(node)
+          add_offence(node, :selector) if DEBUGGER_NODES.include?(node)
         end
       end
     end

data/lib/rubocop/cop/lint/empty_ensure.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_ensure(node)
           _body, ensure_body = *node
 
-          warning(node, :keyword) unless ensure_body
+          add_offence(node, :keyword) unless ensure_body
         end
       end
     end

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -5,23 +5,21 @@ module Rubocop
     module Lint
       # This cop checks whether the end keywords are aligned properly.
       #
-      # For keywords (if, def, etc.) the end is aligned with the start
-      # of the keyword.
+      # Two modes are supported through the AlignWith configuration
+      # parameter. If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, def, etc.). If it's
+      # set to `variable` the `end` shall be aligned with the left-hand-side of
+      # the variable assignment, if there is one.
       #
       # @example
       #
       #   variable = if true
       #              end
       class EndAlignment < Cop
-        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
-
-        def on_def(node)
-          check(node)
-        end
+        include CheckMethods
+        include CheckAssignment
 
-        def on_defs(node)
-          check(node)
-        end
+        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
 
         def on_class(node)
           check(node)
@@ -45,18 +43,57 @@ module Rubocop
 
         private
 
-        def check(node)
-          # discard modifier forms of if/while/until
-          return unless node.loc.end
+        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 if it's an if/unless/while/until.
+          rhs = first_part_of_call_chain(rhs)
+
+          return unless rhs
+
+          case rhs.type
+          when :if, :while, :until
+            return if rhs.loc.respond_to?(:question) # ternary
+
+            offset = if alignment == :variable
+                       rhs.loc.keyword.column - node.loc.expression.column
+                     else
+                       0
+                     end
+            expr = node.loc.expression
+            range = Parser::Source::Range.new(expr.source_buffer,
+                                              expr.begin_pos,
+                                              rhs.loc.keyword.end_pos)
+            check_offset(rhs, range.source, offset)
+            ignore_node(rhs) # Don't check again.
+          end
+        end
+
+        def check(node, *_)
+          check_offset(node, node.loc.keyword.source, 0)
+        end
+
+        def check_offset(node, alignment_base, offset)
+          return if ignored_node?(node)
 
-          kw_loc = node.loc.keyword
           end_loc = node.loc.end
+          return unless end_loc # Discard modifier forms of if/while/until.
+
+          kw_loc = node.loc.keyword
+
+          if kw_loc.line != end_loc.line &&
+              kw_loc.column != end_loc.column + offset
+            add_offence(nil, end_loc,
+                        sprintf(MSG, end_loc.line, end_loc.column,
+                                alignment_base, kw_loc.line, kw_loc.column))
+          end
+        end
 
-          if kw_loc.line != end_loc.line && kw_loc.column != end_loc.column
-            warning(nil,
-                    end_loc,
-                    sprintf(MSG, end_loc.line, end_loc.column,
-                            kw_loc.source, kw_loc.line, kw_loc.column))
+        def alignment
+          a = cop_config['AlignWith']
+          case a
+          when 'keyword', 'variable' then a.to_sym
+          else fail "Unknown AlignWith: #{a}"
           end
         end
       end

data/lib/rubocop/cop/lint/end_in_method.rb

@@ -5,21 +5,15 @@ module Rubocop
     module Lint
       # This cop checks for END blocks in method definitions.
       class EndInMethod < Cop
-        MSG = 'END found in method definition. Use `at_exit` instead.'
-
-        def on_def(node)
-          check(node)
-        end
+        include CheckMethods
 
-        def on_defs(node)
-          check(node)
-        end
+        MSG = 'END found in method definition. Use `at_exit` instead.'
 
         private
 
-        def check(node)
+        def check(node, *_)
           on_node(:postexe, node) do |end_node|
-            warning(end_node, :keyword)
+            add_offence(end_node, :keyword)
           end
         end
       end

data/lib/rubocop/cop/lint/ensure_return.rb

@@ -13,7 +13,7 @@ module Rubocop
           return unless ensure_body
 
           on_node(:return, ensure_body) do |e|
-            warning(e, :expression)
+            add_offence(e, :expression)
           end
         end
       end

data/lib/rubocop/cop/lint/eval.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_send(node)
           receiver, method_name, = *node
 
-          warning(node, :selector) if receiver.nil? && method_name == :eval
+          add_offence(node, :selector) if receiver.nil? && method_name == :eval
         end
       end
     end

data/lib/rubocop/cop/lint/handle_exceptions.rb

@@ -10,7 +10,7 @@ module Rubocop
         def on_resbody(node)
           _exc_list_node, _exc_var_node, body_node = *node
 
-          warning(node, :expression) unless body_node
+          add_offence(node, :expression) unless body_node
         end
       end
     end

data/lib/rubocop/cop/lint/literal_in_condition.rb

@@ -54,7 +54,7 @@ module Rubocop
 
           # if the cond node is literal we obviously have a problem
           if literal?(cond)
-            warning(cond, :expression)
+            add_offence(cond, :expression)
           else
             # alternatively we have to consider a logical node with a
             # literal argument
@@ -94,7 +94,7 @@ module Rubocop
 
         def handle_node(node)
           if literal?(node)
-            warning(node, :expression)
+            add_offence(node, :expression)
           elsif [:send, :and, :or, :begin].include?(node.type)
             check_node(node)
           end

data/lib/rubocop/cop/lint/loop.rb

@@ -19,7 +19,7 @@ module Rubocop
         private
 
         def register_offence(node)
-          warning(node, :keyword)
+          add_offence(node, :keyword)
         end
       end
     end

data/lib/rubocop/cop/lint/parentheses_as_grouped_expression.rb

@@ -26,7 +26,7 @@ module Rubocop
                 Parser::Source::Range.new(expr.source_buffer,
                                           expr.begin_pos - space_length,
                                           expr.begin_pos)
-              warning(nil, space_range)
+              add_offence(nil, space_range)
             end
           end
         end

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -11,7 +11,7 @@ module Rubocop
           return unless node.children.first
           rescue_args = node.children.first.children
           if rescue_args.any? { |a| targets_exception?(a) }
-            warning(node, :expression)
+            add_offence(node, :expression)
           end
         end
 

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -23,7 +23,7 @@ module Rubocop
           return unless outer_local_variable
 
           message = sprintf(MSG, variable.name)
-          warning(variable.declaration_node, :expression, message)
+          add_offence(variable.declaration_node, :expression, message)
         end
       end
     end

data/lib/rubocop/cop/lint/syntax.rb

@@ -25,7 +25,7 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.diagnostics.each do |d|
-            add_offence(d.level, nil, d.location, d.message)
+            add_offence(nil, d.location, d.message, d.level)
           end
         end
       end

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -17,7 +17,7 @@ module Rubocop
 
           expressions.each_cons(2) do |e1, e2|
             if NODE_TYPES.include?(e1.type) || flow_command?(e1)
-              warning(e2, :expression)
+              add_offence(e2, :expression)
             end
           end
         end

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -42,7 +42,7 @@ module Rubocop
                          assignment.node.loc.name
                        end
 
-            warning(nil, location, message)
+            add_offence(nil, location, message)
           end
         end
 
@@ -80,7 +80,7 @@ module Rubocop
           return unless variable.block_local_variable?
           return unless variable.assignments.empty?
           message = sprintf(MSG, variable.name)
-          warning(variable.declaration_node, :expression, message)
+          add_offence(variable.declaration_node, :expression, message)
         end
       end
     end

data/lib/rubocop/cop/lint/useless_comparison.rb

@@ -21,7 +21,7 @@ module Rubocop
           if OPS.include?(op)
             receiver, _method, args = *node
 
-            warning(node, :selector) if receiver == args
+            add_offence(node, :selector) if receiver == args
           end
         end
       end

data/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -13,24 +13,14 @@ module Rubocop
       #    x.attr = 5
       #  end
       class UselessSetterCall < Cop
+        include CheckMethods
+
         MSG = 'Useless setter call to local variable %s.'
         ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
 
-        def on_def(node)
-          _name, args, body = *node
-
-          check_for_useless_assignment(body, args)
-        end
-
-        def on_defs(node)
-          _target, _name, args, body = *node
-
-          check_for_useless_assignment(body, args)
-        end
-
         private
 
-        def check_for_useless_assignment(body, args)
+        def check(_node, _method_name, args, body)
           return unless body
 
           if body.type == :begin
@@ -48,9 +38,9 @@ module Rubocop
           var_name, = *receiver
           return if tracker.contain_object_passed_as_argument?(var_name)
 
-          warning(receiver,
-                  :name,
-                  MSG.format(receiver.loc.name.source))
+          add_offence(receiver,
+                      :name,
+                      MSG.format(receiver.loc.name.source))
         end
 
         def setter_call_to_local_variable?(node)

data/lib/rubocop/cop/lint/void.rb

@@ -32,20 +32,20 @@ module Rubocop
 
           op = node.loc.selector.source
 
-          warning(node, :selector, sprintf(OP_MSG, op)) if OPS.include?(op)
+          add_offence(node, :selector, sprintf(OP_MSG, op)) if OPS.include?(op)
         end
 
         def check_for_var(node)
           if VARS.include?(node.type)
-            warning(node, :name,
-                    sprintf(VAR_MSG, node.loc.name.source))
+            add_offence(node, :name,
+                        sprintf(VAR_MSG, node.loc.name.source))
           end
         end
 
         def check_for_literal(node)
           if LITERALS.include?(node.type)
-            warning(node, :expression,
-                    sprintf(LIT_MSG, node.loc.expression.source))
+            add_offence(node, :expression,
+                        sprintf(LIT_MSG, node.loc.expression.source))
           end
         end
       end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Rails
+      # This cop checks for default_scope calls when it was passed
+      # a lambda or a proc instead of a block.
+      #
+      # @example
+      #
+      #   # incorrect
+      #   default_scope -> { something }
+      #
+      #   # correct
+      #   default_scope { something }
+      class DefaultScope < Cop
+        MSG = 'default_scope expects a block as its sole argument.'
+
+        def on_send(node)
+          return unless command?(:default_scope, node)
+
+          _receiver, _method_name, *args = *node
+
+          return unless args.size == 1
+
+          first_arg = args[0]
+
+          add_offence(first_arg, :expression) if lambda_or_proc?(first_arg)
+        end
+      end
+    end
+  end
+end

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

@@ -8,10 +8,8 @@ module Rubocop
         MSG = 'Prefer has_many :through to has_and_belongs_to_many.'
 
         def on_send(node)
-          receiver, method_name, *_args = *node
-
-          if receiver.nil? && method_name == :has_and_belongs_to_many
-            convention(node, :selector)
+          if command?(:has_and_belongs_to_many, node)
+            add_offence(node, :selector)
           end
         end
       end

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

@@ -18,7 +18,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && BLACKLIST.include?(method_name)
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
 

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

@@ -19,7 +19,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && method_name == :read_attribute
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
       end