rubocop 0.19.1 → 0.20.0

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

@@ -6,7 +6,7 @@ module Rubocop
       # The purpose of the this cop is advise the use of
       # alias_method over the alias keyword whenever possible.
       class Alias < Cop
-        MSG = 'Use alias_method instead of alias.'
+        MSG = 'Use `alias_method` instead of `alias`.'
 
         def on_block(node)
           method, _args, body = *node

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

@@ -196,7 +196,7 @@ module Rubocop
         end
 
         def explicit_hash?(node)
-          !node.loc.begin.nil?
+          node.loc.begin
         end
 
         def multiline?(node)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for uses of *and* and *or*.
       class AndOr < Cop
-        MSG = 'Use %s instead of %s.'
+        MSG = 'Use `%s` instead of `%s`.'
 
         OPS = { 'and' => '&&', 'or' => '||' }
 

data/lib/rubocop/cop/style/{favor_join.rb → array_join.rb}

@@ -8,8 +8,8 @@ module Rubocop
       # Not all cases can reliably checked, due to Ruby's dynamic
       # types, so we consider only cases when the first argument is an
       # array literal or the second is a string literal.
-      class FavorJoin < Cop
-        MSG = 'Favor Array#join over Array#*.'
+      class ArrayJoin < Cop
+        MSG = 'Favor `Array#join` over `Array#*`.'
 
         def on_send(node)
           receiver_node, method_name, *arg_nodes = *node

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for BEGIN blocks.
       class BeginBlock < Cop
-        MSG = 'Avoid the use of BEGIN blocks.'
+        MSG = 'Avoid the use of `BEGIN` blocks.'
 
         def on_preexe(node)
           add_offense(node, :keyword)

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

@@ -4,15 +4,17 @@ module Rubocop
   module Cop
     module Style
       # This cop checks for excessive nesting of conditional and looping
-      # constructs. Despite the cop's name, blocks are not considered as a
+      # constructs. Despite the cop's name, blocks are not considered as an
       # extra level of nesting.
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Cop
         include ConfigurableMax
 
-        NESTING_BLOCKS = [:case, :if, :while, :while_post, :until, :until_post,
-                          :for, :resbody]
+        NESTING_BLOCKS = [
+          :case, :if, :while, :while_post,
+          :until, :until_post, :for, :resbody
+        ]
 
         def investigate(processed_source)
           return unless processed_source.ast
@@ -25,14 +27,16 @@ module Rubocop
         def check_nesting_level(node, max, current_level)
           if NESTING_BLOCKS.include?(node.type)
             unless node.loc.respond_to?(:keyword) &&
-                node.loc.keyword.is?('elsif')
+                   node.loc.keyword.is?('elsif')
               current_level += 1
             end
-            if current_level == max + 1
-              add_offense(node, :expression, message(max)) do
-                self.max = current_level
+            if current_level > max
+              self.max = current_level
+              unless part_of_ignored_node?(node)
+                add_offense(node, :expression, message(max)) do
+                  ignore_node(node)
+                end
               end
-              return
             end
           end
           node.children.each do |child|

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

@@ -75,7 +75,7 @@ module Rubocop
         end
 
         def braces?(arg)
-          !arg.loc.begin.nil?
+          arg.loc.begin
         end
 
         def all_hashes?(args)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for uses of the case equality operator(===).
       class CaseEquality < Cop
-        MSG = 'Avoid the use of the case equality operator(===).'
+        MSG = 'Avoid the use of the case equality operator `===`.'
 
         def on_send(node)
           _receiver, method_name, *_args = *node

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

@@ -31,11 +31,11 @@ module Rubocop
           if pos.column == expected_column
             correct_style_detected
           else
-            msg = 'Indent when ' + if indent
-                                     "one step more than #{base}."
-                                   else
-                                     "as deep as #{base}."
-                                   end
+            msg = 'Indent `when` ' + if indent
+                                       "one step more than `#{base}`."
+                                     else
+                                       "as deep as `#{base}`."
+                                     end
             add_offense(when_node, pos, msg) do
               if pos.column == base_column(case_node, alternative_style)
                 opposite_style_detected

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

@@ -6,13 +6,29 @@ module Rubocop
       # This cop checks for uses of the class/module name instead of
       # self, when defining class/module methods.
       class ClassMethods < Cop
-        MSG = 'Prefer self over class/module for class/module methods.'
+        MSG = 'Use `self.%s` instead of `%s.%s`.'
 
         # TODO: Check if we're in a class/module
         def on_defs(node)
-          definee, _name, _args, _body = *node
+          definee, method_name, _args, _body = *node
 
-          add_offense(definee, :name) if definee.type == :const
+          if definee.type == :const
+            _, class_name = *definee
+            add_offense(definee, :name,
+                        message(class_name, method_name))
+          end
+        end
+
+        private
+
+        def message(class_name, method_name)
+          format(MSG, method_name, class_name, method_name)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.name, 'self')
+          end
         end
       end
     end

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

@@ -15,7 +15,7 @@ module Rubocop
 
         def message(node)
           class_var, = *node
-          MSG.format(class_var)
+          format(MSG, class_var)
         end
       end
     end

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

@@ -10,13 +10,7 @@ module Rubocop
       # enhanced by check for by blocks & procs as arguments of the
       # methods.
       class CollectionMethods < Cop
-        MSG = 'Prefer %s over %s.'
-
-        def preferred_methods
-          if cop_config['PreferredMethods']
-            cop_config['PreferredMethods'].symbolize_keys
-          end
-        end
+        MSG = 'Prefer `%s` over `%s`.'
 
         def on_block(node)
           method, _args, _body = *node
@@ -57,6 +51,22 @@ module Rubocop
         def preferred_method(method)
           preferred_methods[method.to_sym]
         end
+
+        def preferred_methods
+          @preferred_methods ||=
+            begin
+              # Make sure default configuration 'foo' => 'bar' is removed from
+              # the total configuration if there is a 'bar' => 'foo' override.
+              default = default_cop_config['PreferredMethods']
+              merged = cop_config['PreferredMethods']
+              overrides = merged.values - default.values
+              merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+            end
+        end
+
+        def default_cop_config
+          ConfigLoader.default_configuration[cop_name]
+        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Rubocop
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
       class ColonMethodCall < Cop
-        MSG = 'Do not use :: for method calls.'
+        MSG = 'Do not use `::` for method calls.'
 
         def on_send(node)
           receiver, _method_name, *_args = *node

data/lib/rubocop/cop/style/{hash_methods.rb → deprecated_hash_methods.rb}

@@ -5,8 +5,8 @@ module Rubocop
     module Style
       # This cop checks for uses of the deprecated methods Hash#has_key?
       # and Hash#has_value?
-      class HashMethods < Cop
-        MSG = '%s is deprecated in favor of %s.'
+      class DeprecatedHashMethods < Cop
+        MSG = '`Hash#%s` is deprecated in favor of `Hash#%s`.'
 
         DEPRECATED_METHODS = [:has_key?, :has_value?]
 
@@ -15,8 +15,9 @@ module Rubocop
 
           if args.size == 1 && DEPRECATED_METHODS.include?(method_name)
             add_offense(node, :selector,
-                        MSG.format(method_name,
-                                   proper_method_name(method_name)))
+                        format(MSG,
+                               method_name,
+                               proper_method_name(method_name)))
           end
         end
 

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

@@ -15,7 +15,7 @@ module Rubocop
       #   # good
       #   !something.nil?
       class DoubleNegation < Cop
-        MSG = 'Avoid the use of double negation (!!).'
+        MSG = 'Avoid the use of double negation (`!!`).'
 
         def on_send(node)
           return unless not_node?(node)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # Access modifiers should be surrounded by blank lines.
       class EmptyLinesAroundAccessModifier < Cop
-        MSG = 'Keep a blank line before and after %s.'
+        MSG = 'Keep a blank line before and after `%s`.'
 
         PRIVATE_NODE = s(:send, nil, :private)
         PROTECTED_NODE = s(:send, nil, :protected)

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

@@ -5,7 +5,7 @@ module Rubocop
     module Style
       # This cop checks for END blocks.
       class EndBlock < Cop
-        MSG = 'Avoid the use of END blocks. Use `Kernel#at_exit` instead.'
+        MSG = 'Avoid the use of `END` blocks. Use `Kernel#at_exit` instead.'
 
         def on_postexe(node)
           add_offense(node, :keyword)

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

@@ -14,8 +14,8 @@ module Rubocop
       #   # good
       #   if x.even?
       class EvenOdd < Cop
-        MSG_EVEN = 'Use Fixnum.even?'
-        MSG_ODD = 'Use Fixnum.odd?'
+        MSG_EVEN = 'Replace with `Fixnum#even?`.'
+        MSG_ODD = 'Replace with `Fixnum#odd?`.'
 
         ZERO = s(:int, 0)
         ONE = s(:int, 1)

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

@@ -16,7 +16,7 @@ module Rubocop
 
           basename = File.basename(file_path).sub(/\.[^\.]+$/, '')
 
-          unless basename =~ SNAKE_CASE
+          unless basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
             add_offense(nil,
                         source_range(processed_source.buffer,
                                      processed_source[0..0],

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

@@ -12,7 +12,7 @@ module Rubocop
 
         def on_for(node)
           if style == :each
-            add_offense(node, :keyword, 'Prefer *each* over *for*.') do
+            add_offense(node, :keyword, 'Prefer `each` over `for`.') do
               opposite_style_detected
             end
           else
@@ -34,7 +34,7 @@ module Rubocop
             range = Parser::Source::Range.new(processed_source.buffer,
                                               end_pos - 'each'.length,
                                               end_pos)
-            add_offense(range, range, 'Prefer *for* over *each*.') do
+            add_offense(range, range, 'Prefer `for` over `each`.') do
               opposite_style_detected
             end
           else

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

@@ -58,7 +58,7 @@ module Rubocop
 
           method_name = 'String#%' if method_name == :%
 
-          "Favor #{preferred} over #{method_name}."
+          "Favor `#{preferred}` over `#{method_name}`."
         end
       end
     end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop if/unless expression that can be replace with a guard clause.
+      #
+      # @example
+      #
+      #   # bad
+      #   def test
+      #     if something
+      #       work
+      #       work
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return unless something
+      #     work
+      #     work
+      #     work
+      #   end
+      #
+      # It should be extended to handle methods whose body is if/else
+      # or a case expression with a default branch.
+      class GuardClause < Cop
+        include CheckMethods
+        include IfNode
+
+        MSG = 'Use a guard clause instead of wrapping ' \
+              'the code inside a conditional expression.'
+
+        private
+
+        def check(_node, _method_name, _args, body)
+          return unless body
+
+          if body.type == :if
+            check_if_node(body)
+          elsif body.type == :begin
+            expressions = *body
+            last_expr = expressions.last
+
+            check_if_node(last_expr) if last_expr && last_expr.type == :if
+          end
+        end
+
+        def check_if_node(node)
+          _cond, _body, else_body = *node
+
+          return if else_body
+          # discard modifier ifs and ternary_ops
+          return if modifier_if?(node) || ternary_op?(node)
+          # discard short ifs
+          return unless if_length(node) > 3
+
+          add_offense(node, :keyword)
+        end
+
+        def if_length(node)
+          node.loc.end.line - node.loc.keyword.line + 1
+        end
+      end
+    end
+  end
+end

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

@@ -36,23 +36,19 @@ module Rubocop
         def autocorrect(node)
           key = node.children.first.loc.expression
           op = node.loc.operator
-          if style == :ruby19 && !space_before_operator?(op, key) &&
-              config.for_cop('SpaceAroundOperators')['Enabled']
-            # Don't do the correction if there is no space before '=>'. The
-            # combined corrections of this cop and SpaceAroundOperators could
-            # produce code with illegal syntax.
-            return
-          end
 
           @corrections << lambda do |corrector|
             if style == :ruby19
-              corrector.insert_after(key, ' ')
-              corrector.replace(key, key.source.sub(/^:(.*)/, '\1:'))
+              range = Parser::Source::Range.new(key.source_buffer,
+                                                key.begin_pos, op.end_pos)
+              range = range_with_surrounding_space(range, :right)
+              corrector.replace(range,
+                                range.source.sub(/^:(.*\S)\s*=>\s*$/, '\1: '))
             else
               corrector.insert_after(key, ' => ')
               corrector.insert_before(key, ':')
+              corrector.remove(range_with_surrounding_space(op))
             end
-            corrector.remove(range_with_surrounding_space(op))
           end
         end
 

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

@@ -10,8 +10,8 @@ module Rubocop
         include StatementModifier
 
         def error_message(keyword)
-          "Favor modifier #{keyword} usage when you have a single-line body." \
-          ' Another good alternative is the usage of control flow &&/||.'
+          "Favor modifier `#{keyword}` usage when having a single-line body." \
+          ' Another good alternative is the usage of control flow `&&`/`||`.'
         end
 
         def investigate(processed_source)

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

@@ -7,8 +7,8 @@ module Rubocop
       # anonymous functions and uses of the 1.9 lambda syntax for multi-line
       # anonymous functions.
       class Lambda < Cop
-        SINGLE_MSG = 'Use the new lambda literal syntax ->(params) {...}.'
-        MULTI_MSG = 'Use the lambda method for multi-line lambdas.'
+        SINGLE_MSG = 'Use the new lambda literal syntax `->(params) {...}`.'
+        MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'
 
         TARGET = s(:send, nil, :lambda)