rubocop 0.21.0 → 0.22.0

data/lib/rubocop/config_loader.rb

@@ -3,6 +3,11 @@
 require 'yaml'
 require 'pathname'
 
+# Psych can give an error when reading an empty file, so we use syck in Ruby
+# versions where it's available. Also, the problem with empty files does not
+# appear in Ruby 2.
+YAML::ENGINE.yamler = 'syck' if RUBY_VERSION < '2.0.0'
+
 module Rubocop
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
@@ -13,7 +18,7 @@ module Rubocop
     DOTFILE = '.rubocop.yml'
     RUBOCOP_HOME = File.realpath(File.join(File.dirname(__FILE__), '..', '..'))
     DEFAULT_FILE = File.join(RUBOCOP_HOME, 'config', 'default.yml')
-    AUTO_GENERATED_FILE = 'rubocop-todo.yml'
+    AUTO_GENERATED_FILE = '.rubocop_todo.yml'
 
     class << self
       attr_accessor :debug, :auto_gen_config
@@ -34,7 +39,6 @@ module Rubocop
 
         config.deprecation_check do |deprecation_message|
           warn("#{path} - #{deprecation_message}")
-          exit(-1)
         end
 
         config.warn_unless_valid
@@ -49,9 +53,8 @@ module Rubocop
         result = base_hash.merge(derived_hash)
         keys_appearing_in_both = base_hash.keys & derived_hash.keys
         keys_appearing_in_both.each do |key|
-          if base_hash[key].is_a?(Hash)
-            result[key] = merge(base_hash[key], derived_hash[key])
-          end
+          next unless base_hash[key].is_a?(Hash)
+          result[key] = merge(base_hash[key], derived_hash[key])
         end
         result
       end
@@ -59,10 +62,14 @@ module Rubocop
       def base_configs(path, inherit_from)
         configs = Array(inherit_from).map do |f|
           f = File.join(File.dirname(path), f) unless f.start_with?('/')
-          unless auto_gen_config? && f.include?(AUTO_GENERATED_FILE)
-            print 'Inheriting ' if debug?
-            load_file(f)
+
+          if auto_gen_config?
+            next if f.include?(AUTO_GENERATED_FILE)
+            old_auto_config_file_warning if f.include?('rubocop-todo.yml')
           end
+
+          print 'Inheriting ' if debug?
+          load_file(f)
         end
 
         configs.compact
@@ -125,6 +132,12 @@ module Rubocop
         end
         dirs_to_search << Dir.home
       end
+
+      def old_auto_config_file_warning
+        warn 'Attention: rubocop-todo.yml has been renamed to ' \
+             "#{AUTO_GENERATED_FILE}".color(:red)
+        exit(1)
+      end
     end
   end
 end

data/lib/rubocop/cop/cop.rb

@@ -189,14 +189,14 @@ module Rubocop
 
       def custom_severity
         severity = cop_config && cop_config['Severity']
-        if severity
-          if Severity::NAMES.include?(severity.to_sym)
-            severity.to_sym
-          else
-            warn "Warning: Invalid severity '#{severity}'. " +
-                 "Valid severities are #{Severity::NAMES.join(', ')}."
-                 .color(:red)
-          end
+        return unless severity
+
+        if Severity::NAMES.include?(severity.to_sym)
+          severity.to_sym
+        else
+          warn "Warning: Invalid severity '#{severity}'. " +
+               "Valid severities are #{Severity::NAMES.join(', ')}."
+               .color(:red)
         end
       end
     end

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

@@ -30,10 +30,10 @@ module Rubocop
           return if already_processed_node?(node)
 
           _left, right = *node
-          if right.type == :block
-            check_block_alignment(node, right)
-            @inspected_blocks << right
-          end
+          return unless right.type == :block
+
+          check_block_alignment(node, right)
+          @inspected_blocks << right
         end
 
         alias_method :on_or, :on_and
@@ -106,24 +106,24 @@ module Rubocop
           end_loc = block_node.loc.end
           do_loc = block_node.loc.begin # Actually it's either do or {.
           return if do_loc.line == end_loc.line # One-liner, not interesting.
-          if start_loc.column != end_loc.column
-            # We've found that "end" is not aligned with the start node (which
-            # can be a block, a variable assignment, etc). But we also allow
-            # the "end" to be aligned with the start of the line where the "do"
-            # is, which is a style some people use in multi-line chains of
-            # blocks.
-            match = /\S.*/.match(do_loc.source_line)
-            indentation_of_do_line = match.begin(0)
-            if end_loc.column != indentation_of_do_line
-              add_offense(nil,
-                          end_loc,
-                          format(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
+          return unless start_loc.column != end_loc.column
+
+          # We've found that "end" is not aligned with the start node (which
+          # can be a block, a variable assignment, etc). But we also allow
+          # the "end" to be aligned with the start of the line where the "do"
+          # is, which is a style some people use in multi-line chains of
+          # blocks.
+          match = /\S.*/.match(do_loc.source_line)
+          indentation_of_do_line = match.begin(0)
+          return unless end_loc.column != indentation_of_do_line
+
+          add_offense(nil,
+                      end_loc,
+                      format(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
 
         def alt_start_msg(match, start_loc, do_loc, indentation_of_do_line)

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

@@ -33,12 +33,10 @@ module Rubocop
           return if !node.loc.keyword.is?('elsif') && node.loc.end.nil?
 
           condition, = *node
+          return unless on_different_line?(node.loc.keyword.line,
+                                           condition.loc.expression.line)
 
-          if on_different_line?(node.loc.keyword.line,
-                                condition.loc.expression.line)
-            add_offense(condition, :expression,
-                        message(node.loc.keyword.source))
-          end
+          add_offense(condition, :expression, message(node.loc.keyword.source))
         end
 
         def message(keyword)

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

@@ -37,11 +37,10 @@ module Rubocop
         ]
 
         def on_send(node)
-          if DEBUGGER_NODES.include?(node)
-            add_offense(node,
-                        :expression,
-                        format(MSG, node.loc.expression.source))
-          end
+          return unless DEBUGGER_NODES.include?(node)
+          add_offense(node,
+                      :expression,
+                      format(MSG, node.loc.expression.source))
         end
       end
     end

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

@@ -46,16 +46,17 @@ module Rubocop
           super
 
           receiver, method_name, *args = *node
-          if visibility_and_def_on_same_line?(receiver, method_name, args)
-            expr = node.loc.expression
-            method_def = args.first
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              method_def.loc.keyword.end_pos)
-            check_offset(method_def, range.source,
-                         method_def.loc.keyword.begin_pos - expr.begin_pos)
-            ignore_node(method_def) # Don't check the same `end` again.
-          end
+          return unless visibility_and_def_on_same_line?(receiver, method_name,
+                                                         args)
+
+          expr = node.loc.expression
+          method_def = args.first
+          range = Parser::Source::Range.new(expr.source_buffer,
+                                            expr.begin_pos,
+                                            method_def.loc.keyword.end_pos)
+          check_offset(method_def, range.source,
+                       method_def.loc.keyword.begin_pos - expr.begin_pos)
+          ignore_node(method_def) # Don't check the same `end` again.
         end
 
         private

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

@@ -15,18 +15,17 @@ module Rubocop
         def on_send(node)
           _receiver, method_name, args = *node
           return if operator?(method_name) || method_name.to_s.end_with?('=')
+          return unless args && args.loc.expression.source.start_with?('(')
 
-          if args && args.loc.expression.source.start_with?('(')
-            space_length = spaces_before_left_parenthesis(node)
-            if space_length > 0
-              expr = args.loc.expression
-              space_range =
-                Parser::Source::Range.new(expr.source_buffer,
-                                          expr.begin_pos - space_length,
-                                          expr.begin_pos)
-              add_offense(nil, space_range)
-            end
-          end
+          space_length = spaces_before_left_parenthesis(node)
+          return unless space_length > 0
+          expr = args.loc.expression
+          space_range =
+            Parser::Source::Range.new(expr.source_buffer,
+                                      expr.begin_pos - space_length,
+                                      expr.begin_pos)
+
+          add_offense(nil, space_range)
         end
 
         private

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

@@ -42,13 +42,13 @@ module Rubocop
 
         def check_ternary(arg, node)
           condition, _, _ = *arg
-          if offense?(condition)
-            expr = node.loc.expression
-            range = Parser::Source::Range.new(expr.source_buffer,
-                                              expr.begin_pos,
-                                              condition.loc.expression.end_pos)
-            add_offense(range, range)
-          end
+          return unless offense?(condition)
+
+          expr = node.loc.expression
+          range = Parser::Source::Range.new(expr.source_buffer,
+                                            expr.begin_pos,
+                                            condition.loc.expression.end_pos)
+          add_offense(range, range)
         end
 
         def check_send(arg, node)

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

@@ -10,9 +10,9 @@ module Rubocop
         def on_resbody(node)
           return unless node.children.first
           rescue_args = node.children.first.children
-          if rescue_args.any? { |a| targets_exception?(a) }
-            add_offense(node, :expression)
-          end
+          return unless rescue_args.any? { |a| targets_exception?(a) }
+
+          add_offense(node, :expression)
         end
 
         def targets_exception?(rescue_arg_node)

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

@@ -19,14 +19,13 @@ module Rubocop
             next unless final_node && final_node.type == :send
 
             receiver, method_name, *args = *final_node
+            next unless method_name == :to_s && args.empty?
 
-            if method_name == :to_s && args.empty?
-              add_offense(
-                final_node,
-                :selector,
-                receiver ? MSG_DEFAULT : MSG_SELF
-              )
-            end
+            add_offense(
+              final_node,
+              :selector,
+              receiver ? MSG_DEFAULT : MSG_SELF
+            )
           end
         end
 

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

@@ -16,9 +16,8 @@ module Rubocop
           expressions = *node
 
           expressions.each_cons(2) do |e1, e2|
-            if NODE_TYPES.include?(e1.type) || flow_command?(e1)
-              add_offense(e2, :expression)
-            end
+            next unless NODE_TYPES.include?(e1.type) || flow_command?(e1)
+            add_offense(e2, :expression)
           end
         end
 

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

@@ -11,25 +11,12 @@ module Rubocop
       #     puts used
       #   end
       class UnusedBlockArgument < Cop
+        include UnusedArgument
         include Util
 
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
-        end
-
         def check_argument(variable)
           return unless variable.block_argument?
-          return if variable.name.to_s.start_with?('_')
-          return if variable.referenced?
-
-          message = message(variable)
-          add_offense(variable.declaration_node, :name, message)
+          super
         end
 
         def message(variable)

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

@@ -11,23 +11,11 @@ module Rubocop
       #     puts used
       #   end
       class UnusedMethodArgument < Cop
-        def join_force?(force_class)
-          force_class == VariableForce
-        end
-
-        def after_leaving_scope(scope, _variable_table)
-          scope.variables.each_value do |variable|
-            check_argument(variable)
-          end
-        end
+        include UnusedArgument
 
         def check_argument(variable)
           return unless variable.method_argument?
-          return if variable.name.to_s.start_with?('_')
-          return if variable.referenced?
-
-          message = message(variable)
-          add_offense(variable.declaration_node, :name, message)
+          super
         end
 
         def message(variable)

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

@@ -16,13 +16,12 @@ module Rubocop
         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
+          op = node.loc.selector.source
+          return unless OPS.include?(op)
 
-            add_offense(node, :selector) if receiver == args
-          end
+          receiver, _method, args = *node
+          add_offense(node, :selector) if receiver == args
         end
       end
     end

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

@@ -29,6 +29,7 @@ module Rubocop
 
         def check_for_void_op(node)
           return unless node.type == :send
+          return unless node.loc.selector
 
           op = node.loc.selector.source
 
@@ -36,17 +37,14 @@ module Rubocop
         end
 
         def check_for_var(node)
-          if VARS.include?(node.type)
-            add_offense(node, :name,
-                        format(VAR_MSG, node.loc.name.source))
-          end
+          return unless VARS.include?(node.type)
+          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
         end
 
         def check_for_literal(node)
-          if LITERALS.include?(node.type)
-            add_offense(node, :expression,
-                        format(LIT_MSG, node.loc.expression.source))
-          end
+          return unless LITERALS.include?(node.type)
+          add_offense(node, :expression,
+                      format(LIT_MSG, node.loc.expression.source))
         end
       end
     end

data/lib/rubocop/cop/mixin/autocorrect_alignment.rb

@@ -8,11 +8,13 @@ module Rubocop
     module AutocorrectAlignment
       def check_alignment(items, base_column = nil)
         base_column ||= items.first.loc.column unless items.empty?
-        items.each_cons(2) do |prev, current|
-          if current.loc.line > prev.loc.line && start_of_line?(current.loc)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line && start_of_line?(current.loc)
             @column_delta = base_column - current.loc.column
             add_offense(current, :expression) if @column_delta != 0
           end
+          prev_line = current.loc.line
         end
       end
 

data/lib/rubocop/cop/mixin/autocorrect_unless_changing_ast.rb

@@ -11,9 +11,7 @@ module Rubocop
         new_source = rewrite_node(node)
 
         # Make the correction only if it doesn't change the AST.
-        if node != SourceParser.parse(new_source).ast
-          fail CorrectionNotPossible
-        end
+        fail CorrectionNotPossible if node != SourceParser.parse(new_source).ast
 
         @corrections << c
       end