rubocop 0.19.1 → 0.20.0

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

@@ -12,6 +12,9 @@ module Rubocop
       #   some_str = 'ala' +
       #              'bala'
       #
+      #   some_str = 'ala' <<
+      #              'bala'
+      #
       #   # good
       #   some_str = 'ala' \
       #              'bala'
@@ -36,22 +39,26 @@ module Rubocop
           receiver, method, arg = *node
 
           # TODO: Report Emacs bug.
-          return false unless :+ == method
+          return false unless [:+, :<<].include?(method)
 
-          return false unless string_type?(receiver.type)
+          return false unless string_type?(receiver)
 
-          return false unless string_type?(arg.type)
+          return false unless string_type?(arg)
 
-          plus_at_line_end?(node.loc.expression.source)
+          expression = node.loc.expression.source
+          concatenator_at_line_end?(expression)
         end
 
-        def plus_at_line_end?(expression)
-          # check if the first line of the expression ends with a +
-          expression =~ /.+\+\s*$/
+        def concatenator_at_line_end?(expression)
+          # check if the first line of the expression ends with a + or a <<
+          expression =~ /.+(\+|<<)\s*$/
         end
 
-        def string_type?(node_type)
-          [:str, :dstr].include?(node_type)
+        def string_type?(node)
+          return false unless [:str, :dstr].include?(node.type)
+
+          # we care only about quotes-delimited literals
+          node.loc.begin && ["'", '"'].include?(node.loc.begin.source)
         end
       end
     end

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

@@ -42,7 +42,7 @@ module Rubocop
         end
 
         def error_message(node)
-          "Never use then for multi-line #{node.loc.keyword.source}."
+          "Never use `then` for multi-line `#{node.loc.keyword.source}`."
         end
       end
     end

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

@@ -5,8 +5,8 @@ module Rubocop
     module Style
       # This cop checks for multi-line ternary op expressions.
       class MultilineTernaryOperator < Cop
-        MSG =
-          'Avoid multi-line ?: (the ternary operator); use if/unless instead.'
+        MSG = 'Avoid multi-line ?: (the ternary operator);' \
+              ' use `if`/`unless` instead.'
 
         def on_if(node)
           loc = node.loc

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of if with a negated condition. Only ifs
+      # without else are considered.
+      class NegatedIf < Cop
+        include NegativeConditional
+
+        def on_if(node)
+          return unless node.loc.respond_to?(:keyword)
+          return if node.loc.keyword.is?('elsif')
+
+          check(node)
+        end
+
+        def error_message
+          'Favor `unless` over `if` for negative conditions.'
+        end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition, _body, _rest = *node
+            # unwrap the negated portion of the condition (a send node)
+            pos_condition, _method, = *condition
+            corrector.replace(node.loc.keyword, 'unless')
+            corrector.replace(condition.loc.expression,
+                              pos_condition.loc.expression.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of while with a negated condition.
+      class NegatedWhile < Cop
+        include NegativeConditional
+
+        def on_while(node)
+          check(node)
+        end
+
+        def error_message
+          'Favor `until` over `while` for negative conditions.'
+        end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            condition, _body, _rest = *node
+            # unwrap the negated portion of the condition (a send node)
+            pos_condition, _method, = *condition
+            corrector.replace(node.loc.keyword, 'until')
+            corrector.replace(condition.loc.expression,
+                              pos_condition.loc.expression.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
-        MSG = 'Ternary operators must not be nested. Prefer if/else ' \
+        MSG = 'Ternary operators must not be nested. Prefer `if`/`else` ' \
               'constructs instead.'
 
         def on_if(node)

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

@@ -9,29 +9,33 @@ module Rubocop
       #
       #  # bad
       #  if x == nil
-      #  if x != nil
       #
       #  # good
       #  if x.nil?
-      #  if !x.nil?
       class NilComparison < Cop
-        MSG = 'Prefer the use of the nil? predicate.'
+        MSG = 'Prefer the use of the `nil?` predicate.'
 
-        OPS = %w(== === !=)
+        OPS = [:==, :===]
 
         NIL_NODE = s(:nil)
 
         def on_send(node)
-          # lambda.() does not have a selector
-          return unless node.loc.selector
-          op = node.loc.selector.source
-
-          if OPS.include?(op)
-            _receiver, _method, args = *node
+          _receiver, method, args = *node
 
+          if OPS.include?(method)
             add_offense(node, :selector) if args == NIL_NODE
           end
         end
+
+        private
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            new_code = expr.source.sub(/\s*==\s*nil/, '.nil?')
+            corrector.replace(expr, new_code)
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for non-nil checks, which are usually redundant.
+      #
+      # @example
+      #
+      #  # bad
+      #  if x != nil
+      #  if !x.nil?
+      #
+      #  # good
+      #  if x
+      class NonNilCheck < Cop
+        MSG = 'Explicit non-nil checks are usually redundant.'
+
+        NIL_NODE = s(:nil)
+
+        def on_send(node)
+          receiver, method, args = *node
+
+          return unless [:!=, :!].include?(method)
+
+          if method == :!=
+            add_offense(node, :selector) if args == NIL_NODE
+          elsif method == :!
+            add_offense(node, :expression) if nil_check?(receiver)
+          end
+        end
+
+        private
+
+        def nil_check?(node)
+          return false unless node && node.type == :send
+
+          _receiver, method, *_args = *node
+          method == :nil?
+        end
+
+        def autocorrect(node)
+          receiver, method, _args = *node
+
+          if method == :!=
+            autocorrect_comparison(node)
+          elsif method == :!
+            autocorrect_non_nil(node, receiver)
+          end
+        end
+
+        def autocorrect_comparison(node)
+          @corrections << lambda do |corrector|
+            expr = node.loc.expression
+            new_code = expr.source.sub(/\s*!=\s*nil/, '')
+            corrector.replace(expr, new_code)
+          end
+        end
+
+        def autocorrect_non_nil(node, inner_node)
+          @corrections << lambda do |corrector|
+            receiver, _method, _args = *inner_node
+            corrector.replace(node.loc.expression,
+                              receiver.loc.expression.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for uses if the keyword *not* instead of !.
       class Not < Cop
-        MSG = 'Use ! instead of not.'
+        MSG = 'Use `!` instead of `not`.'
 
         def on_send(node)
           _receiver, method_name, *args = *node
@@ -16,6 +16,30 @@ module Rubocop
             add_offense(node, :selector)
           end
         end
+
+        private
+
+        def autocorrect(node)
+          c = correction(node)
+          new_source = rewrite_node(node, c)
+
+          # Make the correction only if it doesn't change the AST.
+          @corrections << c if node == SourceParser.parse(new_source).ast
+        end
+
+        def rewrite_node(node, correction)
+          processed_source = SourceParser.parse(node.loc.expression.source)
+          c = correction(processed_source.ast)
+          Corrector.new(processed_source.buffer, [c]).rewrite
+        end
+
+        def correction(node)
+          lambda do |corrector|
+            old_source = node.loc.expression.source
+            new_source = old_source.sub(/not\s+/, '!')
+            corrector.replace(node.loc.expression, new_source)
+          end
+        end
       end
     end
   end

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

@@ -18,7 +18,7 @@ module Rubocop
           check(node)
         end
 
-        def on_fload(node)
+        def on_float(node)
           check(node)
         end
 

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

@@ -4,19 +4,19 @@ module Rubocop
   module Cop
     module Style
       # This cop makes sure that certain operator methods have their sole
-      # parameter named *other*.
+      # parameter named `other`.
       class OpMethod < Cop
-        MSG = 'When defining the %s operator, name its argument *other*.'
+        MSG = 'When defining the `%s` operator, name its argument `other`.'
 
         BLACKLISTED = [:+@, :-@, :[], :[]=, :<<]
 
-        TARGET_ARGS = s(:args, s(:arg, :other))
+        TARGET_ARGS = [s(:args, s(:arg, :other)), s(:args, s(:arg, :_other))]
 
         def on_def(node)
           name, args, _body = *node
 
           if name !~ /\A\w/ && !BLACKLISTED.include?(name) &&
-              args.children.size == 1 && args != TARGET_ARGS
+              args.children.size == 1 && !TARGET_ARGS.include?(args)
             add_offense(args.children[0], :expression,
                         format(MSG, name))
           end

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

@@ -47,7 +47,7 @@ module Rubocop
         def message(node)
           kw = node.loc.keyword.source
           article = kw == 'while' ? 'a' : 'an'
-          "Don't use parentheses around the condition of #{article} #{kw}."
+          "Don't use parentheses around the condition of #{article} `#{kw}`."
         end
 
         def autocorrect(node)

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

@@ -34,7 +34,7 @@ module Rubocop
         def message(method_name, prefix)
           new_name = method_name.sub(prefix, '')
           new_name << '?' unless method_name.end_with?('?')
-          "Rename #{method_name} to #{new_name}."
+          "Rename `#{method_name}` to `#{new_name}`."
         end
 
         def prefix_blacklist

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

@@ -6,7 +6,7 @@ module Rubocop
       # This cops checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
       class Proc < Cop
-        MSG = 'Use proc instead of Proc.new.'
+        MSG = 'Use `proc` instead of `Proc.new`.'
 
         TARGET = s(:send, s(:const, nil, :Proc), :new)
 

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

@@ -56,9 +56,10 @@ module Rubocop
         def message(method)
           case style
           when :compact
-            "Provide an exception object as an argument to #{method}."
+            "Provide an exception object as an argument to `#{method}`."
           when :exploded
-            "Provide an exception class and message as arguments to #{method}."
+            "Provide an exception class and message as " \
+            "arguments to `#{method}`."
           end
         end
       end

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

@@ -7,7 +7,7 @@ module Rubocop
       class RescueModifier < Cop
         include CheckMethods
 
-        MSG = 'Avoid using rescue in its modifier form.'
+        MSG = 'Avoid using `rescue` in its modifier form.'
 
         def on_rescue(node)
           return if ignored_node?(node)

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

@@ -51,7 +51,7 @@ module Rubocop
           if receiver == target_node
             add_offense(node,
                         :expression,
-                        "Use self-assignment shorthand #{method_name}=.")
+                        "Use self-assignment shorthand `#{method_name}=`.")
           end
         end
 
@@ -64,7 +64,7 @@ module Rubocop
             operator = rhs.loc.operator.source
             add_offense(node,
                         :expression,
-                        "Use self-assignment shorthand #{operator}=.")
+                        "Use self-assignment shorthand `#{operator}=`.")
           end
         end
       end

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

@@ -12,11 +12,14 @@ module Rubocop
 
         def on_rescue(node)
           if style == :semantic
-            begin_node, rescue_node = *node
+            begin_node, *rescue_nodes, _else_node = *node
 
             check_for(:raise, begin_node)
-            check_for(:fail, rescue_node)
-            allow(:raise, rescue_node)
+
+            rescue_nodes.each do |rescue_node|
+              check_for(:fail, rescue_node)
+              allow(:raise, rescue_node)
+            end
           end
         end
 

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

@@ -34,7 +34,7 @@ module Rubocop
 
         def message(method_name)
           args = target_args(method_name).join(', ')
-          "Name `#{method_name}` block params |#{args}|."
+          "Name `#{method_name}` block params `|#{args}|`."
         end
 
         def methods

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

@@ -49,11 +49,12 @@ module Rubocop
         end
 
         def break_line_before(range, node, corrector, indent_steps)
-          corrector.insert_before(range,
-                                  "\n" + ' ' * (node.loc.keyword.column +
-                                                indent_steps *
-                                                IndentationWidth::
-                                                CORRECT_INDENTATION))
+          corrector.insert_before(
+            range,
+            "\n" + ' ' * (node.loc.keyword.column +
+                          indent_steps *
+                          IndentationWidth::CORRECT_INDENTATION)
+          )
         end
 
         def move_comment(eol_comment, node, corrector)