rubocop 0.20.1 → 0.21.0

data/lib/rubocop/config_loader.rb

@@ -31,33 +31,15 @@ module Rubocop
 
         hash.delete('inherit_from')
         config = Config.new(hash, path)
-        deprecation_check(config)
-        config.warn_unless_valid
-        make_excludes_absolute(config)
-        config
-      end
 
-      def deprecation_check(config)
-        return unless config['AllCops']
-        if config['AllCops']['Excludes']
-          warn('AllCops/Excludes was renamed to AllCops/Exclude')
-          exit(-1)
-        elsif config['AllCops']['Includes']
-          warn('AllCops/Includes was renamed to AllCops/Include')
+        config.deprecation_check do |deprecation_message|
+          warn("#{path} - #{deprecation_message}")
           exit(-1)
         end
-      end
 
-      def make_excludes_absolute(config)
-        if config['AllCops'] && config['AllCops']['Exclude']
-          config['AllCops']['Exclude'].map! do |exclude_elem|
-            if exclude_elem.is_a?(String) && !exclude_elem.start_with?('/')
-              File.join(config.base_dir_for_path_parameters, exclude_elem)
-            else
-              exclude_elem
-            end
-          end
-        end
+        config.warn_unless_valid
+        config.make_excludes_absolute
+        config
       end
 
       # Return a recursive merge of two hashes. That is, a normal hash merge,
@@ -102,24 +84,11 @@ module Rubocop
         found_files = config_files_in_path(config_file)
         if found_files.any? && found_files.last != config_file
           print 'AllCops/Exclude ' if debug?
-          add_excludes_from_higher_level(config, load_file(found_files.last))
+          config.add_excludes_from_higher_level(load_file(found_files.last))
         end
         merge_with_default(config, config_file)
       end
 
-      def add_excludes_from_higher_level(config, highest_config)
-        if highest_config['AllCops'] && highest_config['AllCops']['Exclude']
-          config['AllCops'] ||= {}
-          excludes = config['AllCops']['Exclude'] ||= []
-          highest_config['AllCops']['Exclude'].each do |path|
-            unless path.is_a?(Regexp) || path.start_with?('/')
-              path = File.join(File.dirname(highest_config.loaded_path), path)
-            end
-            excludes << path unless excludes.include?(path)
-          end
-        end
-      end
-
       def default_configuration
         @default_configuration ||= begin
                                      print 'Default ' if debug?

data/lib/rubocop/config_store.rb

@@ -21,7 +21,6 @@ module Rubocop
 
     def options_config=(options_config)
       loaded_config = ConfigLoader.load_file(options_config)
-      ConfigLoader.make_excludes_absolute(loaded_config)
       @options_config = ConfigLoader.merge_with_default(loaded_config,
                                                         options_config)
     end

data/lib/rubocop/cop/commissioner.rb

@@ -28,8 +28,9 @@ module Rubocop
         end
       end
 
-      def initialize(cops, options = {})
+      def initialize(cops, forces, options = {})
         @cops = cops
+        @forces = forces
         @options = options
         reset_errors
       end
@@ -52,7 +53,8 @@ module Rubocop
       def investigate(processed_source)
         reset_errors
         prepare(processed_source)
-        invoke_cops_callback(processed_source)
+        invoke_custom_processing(@cops, processed_source)
+        invoke_custom_processing(@forces, processed_source)
         process(processed_source.ast) if processed_source.ast
         @cops.each_with_object([]) do |cop, offenses|
           filename = processed_source.buffer.name
@@ -72,18 +74,19 @@ module Rubocop
         @cops.each { |cop| cop.processed_source = processed_source }
       end
 
-      # There are cops that require their own custom processing.
+      # There are cops/forces that require their own custom processing.
       # If they define the #investigate method, all input parameters passed
       # to the commissioner will be passed to the cop too in order to do
       # its own processing.
-      def invoke_cops_callback(processed_source)
-        @cops.each do |cop|
+      def invoke_custom_processing(cops_or_forces, processed_source)
+        cops_or_forces.each do |cop|
           next unless cop.respond_to?(:investigate)
 
-          filename = processed_source.buffer.name
-
-          # ignore files that are of no interest to the cop in question
-          next unless cop.relevant_file?(filename)
+          if cop.respond_to?(:relevant_file?)
+            # ignore files that are of no interest to the cop in question
+            filename = processed_source.buffer.name
+            next unless cop.relevant_file?(filename)
+          end
 
           with_cop_error_handling(cop) do
             cop.investigate(processed_source)

data/lib/rubocop/cop/cop.rb

@@ -2,6 +2,8 @@
 
 module Rubocop
   module Cop
+    class CorrectionNotPossible < Exception; end
+
     # Store for all cops with helper functions
     class CopStore < ::Array
       # @return [Array<String>] list of types for current cops.
@@ -86,6 +88,10 @@ module Rubocop
         @corrections = []
       end
 
+      def join_force?(_force_class)
+        false
+      end
+
       def cop_config
         @config.for_cop(self)
       end
@@ -102,7 +108,7 @@ module Rubocop
         debug? || @options[:display_cop_names]
       end
 
-      def message(node = nil)
+      def message(_node = nil)
         self.class::MSG
       end
 
@@ -123,9 +129,13 @@ module Rubocop
         message ||= message(node)
         message = display_cop_names? ? "#{name}: #{message}" : message
 
-        autocorrect(node) if autocorrect?
-        @offenses << Offense.new(severity, location, message, name,
-                                 autocorrect?)
+        corrected = begin
+                      autocorrect(node) if autocorrect?
+                      autocorrect?
+                    rescue CorrectionNotPossible
+                      false
+                    end
+        @offenses << Offense.new(severity, location, message, name, corrected)
         yield if block_given?
       end
 
@@ -162,7 +172,9 @@ module Rubocop
         patterns = cop_config && cop_config[parameter]
         return default_result unless patterns
         path = config.path_relative_to_config(file)
-        patterns.any? { |pattern| match_path?(pattern, path) }
+        patterns.any? do |pattern|
+          match_path?(pattern, path, config.loaded_path)
+        end
       end
 
       def enabled_line?(line_number)

data/lib/rubocop/cop/force.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # A scaffold for concrete forces.
+    class Force
+      attr_reader :cops
+
+      def self.all
+        @all ||= []
+      end
+
+      def self.inherited(subclass)
+        all << subclass
+      end
+
+      def self.force_name
+        name.split('::').last
+      end
+
+      def initialize(cops)
+        @cops = cops
+      end
+
+      def name
+        self.class.force_name
+      end
+
+      def run_hook(method_name, *args)
+        cops.each do |cop|
+          next unless cop.respond_to?(method_name)
+          cop.send(method_name, *args)
+        end
+      end
+
+      def investigate(_processed_source)
+        # Do custom processing and invoke #run_hook at arbitrary timing.
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ignored_node.rb

@@ -5,26 +5,26 @@ module Rubocop
     # Handles adding and checking ignored nodes.
     module IgnoredNode
       def ignore_node(node)
-        @ignored_nodes ||= []
-        @ignored_nodes << node
+        ignored_nodes << node
       end
 
       def part_of_ignored_node?(node)
-        return false unless @ignored_nodes
         expression = node.loc.expression
-        @ignored_nodes.each do |ignored_node|
-          if ignored_node.loc.expression.begin_pos <= expression.begin_pos &&
+        ignored_nodes.any? do |ignored_node|
+          ignored_node.loc.expression.begin_pos <= expression.begin_pos &&
             ignored_node.loc.expression.end_pos >= expression.end_pos
-            return true
-          end
         end
-
-        false
       end
 
       def ignored_node?(node)
         # Same object found in array?
-        @ignored_nodes && @ignored_nodes.any? { |n| n.eql?(node) }
+        ignored_nodes.any? { |n| n.equal?(node) }
+      end
+
+      private
+
+      def ignored_nodes
+        @ignored_nodes ||= []
       end
     end
   end

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

@@ -30,7 +30,7 @@ module Rubocop
 
         MSG_FORMAT = 'Ambiguous %{actual} operator. Parenthesize the method ' \
                      "arguments if it's surely a %{actual} operator, or add " \
-                     'a whitespace to the right of the %{operator} if it ' \
+                     'a whitespace to the right of the `%{operator}` if it ' \
                      'should be a %{possible}.'
 
         private

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

@@ -19,7 +19,7 @@ module Rubocop
 
         MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
               "if it's surely a regexp literal, or add a whitespace to the " \
-              'right of the / if it should be a division.'
+              'right of the `/` if it should be a division.'
 
         private
 
@@ -27,7 +27,7 @@ module Rubocop
           diagnostic.reason == :ambiguous_literal
         end
 
-        def alternative_message(diagnostic)
+        def alternative_message(_diagnostic)
           MSG
         end
       end

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

@@ -14,7 +14,7 @@ module Rubocop
       class BlockAlignment < Cop
         include CheckAssignment
 
-        MSG = 'end at %d, %d is not aligned with %s at %d, %d%s'
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d%s'
 
         def initialize(config = nil, options = nil)
           super
@@ -131,7 +131,7 @@ module Rubocop
               start_loc.column == indentation_of_do_line
             ''
           else
-            " or #{match[0]} at #{do_loc.line}, #{indentation_of_do_line}"
+            " or `#{match[0]}` at #{do_loc.line}, #{indentation_of_do_line}"
           end
         end
 

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

@@ -30,6 +30,8 @@ module Rubocop
         private
 
         def check(node)
+          return if !node.loc.keyword.is?('elsif') && node.loc.end.nil?
+
           condition, = *node
 
           if on_different_line?(node.loc.keyword.line,

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

@@ -5,13 +5,18 @@ module Rubocop
     module Lint
       # This cop checks for calls to debugger or pry.
       class Debugger < Cop
-        MSG = 'Remove calls to `debugger`.'
+        MSG = 'Remove debugger entry point `%s`.'
 
         # debugger call node
         #
         # (send nil :debugger)
         DEBUGGER_NODE = s(:send, nil, :debugger)
 
+        # byebug call node
+        #
+        # (send nil :byebug)
+        BYEBUG_NODE = s(:send, nil, :byebug)
+
         # binding.pry node
         #
         # (send
@@ -24,10 +29,19 @@ module Rubocop
         #   (send nil :binding) :remote_pry)
         REMOTE_PRY_NODE = s(:send, s(:send, nil, :binding), :remote_pry)
 
-        DEBUGGER_NODES = [DEBUGGER_NODE, PRY_NODE, REMOTE_PRY_NODE]
+        DEBUGGER_NODES = [
+          DEBUGGER_NODE,
+          BYEBUG_NODE,
+          PRY_NODE,
+          REMOTE_PRY_NODE
+        ]
 
         def on_send(node)
-          add_offense(node, :selector) if DEBUGGER_NODES.include?(node)
+          if DEBUGGER_NODES.include?(node)
+            add_offense(node,
+                        :expression,
+                        format(MSG, node.loc.expression.source))
+          end
         end
       end
     end

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

@@ -20,7 +20,7 @@ module Rubocop
         include CheckAssignment
         include ConfigurableEnforcedStyle
 
-        MSG = 'end at %d, %d is not aligned with %s at %d, %d'
+        MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d'
 
         def on_class(node)
           check(node)
@@ -43,6 +43,8 @@ module Rubocop
         end
 
         def on_send(node)
+          super
+
           receiver, method_name, *args = *node
           if visibility_and_def_on_same_line?(receiver, method_name, args)
             expr = node.loc.expression
@@ -58,16 +60,6 @@ module Rubocop
 
         private
 
-        # Returns true for constructs such as
-        # private def my_method
-        # which are allowed in Ruby 2.1 and later.
-        def visibility_and_def_on_same_line?(receiver, method_name, args)
-          !receiver &&
-            [:public, :protected, :private,
-             :module_function].include?(method_name) &&
-            args.size == 1 && [:def, :defs].include?(args.first.type)
-        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

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

@@ -10,7 +10,7 @@ module Rubocop
       #
       # puts (x + y)
       class ParenthesesAsGroupedExpression < Cop
-        MSG = '(...) interpreted as grouped expression.'
+        MSG = '`(...)` interpreted as grouped expression.'
 
         def on_send(node)
           _receiver, method_name, args = *node

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

@@ -18,6 +18,17 @@ module Rubocop
         def targets_exception?(rescue_arg_node)
           Util.const_name(rescue_arg_node) == 'Exception'
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(
+                node.children.first.children.first.loc.expression,
+                :left
+              )
+            )
+          end
+        end
       end
     end
   end

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

@@ -8,15 +8,13 @@ module Rubocop
       # This is a mimic of the warning
       # "shadowing outer local variable - foo" from `ruby -cw`.
       class ShadowingOuterLocalVariable < Cop
-        include VariableInspector
+        MSG = 'Shadowing outer local variable - `%s`.'
 
-        MSG = 'Shadowing outer local variable - `%s`'
-
-        def investigate(processed_source)
-          inspect_variables(processed_source.ast)
+        def join_force?(force_class)
+          force_class == VariableForce
         end
 
-        def before_declaring_variable(variable)
+        def before_declaring_variable(variable, variable_table)
           return if variable.name.to_s.start_with?('_')
 
           outer_local_variable = variable_table.find_variable(variable.name)

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Lint
+      # This cop checks for underscore-prefixed variables that are actually
+      # used.
+      class UnderscorePrefixedVariableName < Cop
+        MSG = 'Do not use prefix `_` for a variable that is used.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_variable(variable)
+          end
+        end
+
+        def check_variable(variable)
+          return unless variable.name.to_s.start_with?('_')
+          return if variable.references.empty?
+          return if variable.references.none?(&:explicit?)
+
+          node = variable.declaration_node
+
+          location = if node.type == :match_with_lvasgn
+                       node.children.first.loc.expression
+                     else
+                       node.loc.name
+                     end
+
+          add_offense(nil, location)
+        end
+      end
+    end
+  end
+end