rubocop 0.31.0 → 0.35.0

data/lib/rubocop/cop/commissioner.rb

@@ -30,7 +30,7 @@ module RuboCop
       end
 
       callback_methods.each do |callback|
-        class_eval <<-EOS
+        class_eval <<-EOS, __FILE__, __LINE__
           def #{callback}(node)
             @cops.each do |cop|
               next unless cop.respond_to?(:#{callback})
@@ -46,15 +46,12 @@ module RuboCop
 
       def investigate(processed_source)
         reset_errors
+        remove_irrelevant_cops(processed_source.buffer.name)
         prepare(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
-          # ignore files that are of no interest to the cop in question
-          offenses.concat(cop.offenses) if cop.relevant_file?(filename)
-        end
+        @cops.flat_map(&:offenses)
       end
 
       private
@@ -63,6 +60,10 @@ module RuboCop
         @errors = Hash.new { |hash, k| hash[k] = [] }
       end
 
+      def remove_irrelevant_cops(filename)
+        @cops.reject! { |cop| cop.excluded_file?(filename) }
+      end
+
       # TODO: Bad design.
       def prepare(processed_source)
         @cops.each { |cop| cop.processed_source = processed_source }
@@ -76,12 +77,6 @@ module RuboCop
         cops_or_forces.each do |cop|
           next unless cop.respond_to?(:investigate)
 
-          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)
           end

data/lib/rubocop/cop/cop.rb

@@ -49,7 +49,7 @@ module RuboCop
     #
     # The Cop class is meant to be extended.
     #
-    # Cops track offenses and can autocorrect them of the fly.
+    # Cops track offenses and can autocorrect them on the fly.
     #
     # A commissioner object is responsible for traversing the AST and invoking
     # the specific callbacks on each cop.
@@ -66,6 +66,7 @@ module RuboCop
     #   end
     class Cop
       extend AST::Sexp
+      extend NodePattern::Macros
       include Util
       include IgnoredNode
       include AutocorrectLogic
@@ -133,11 +134,16 @@ module RuboCop
       end
 
       def display_style_guide?
-        style_guide_url &&
+        (style_guide_url || reference_url) &&
           (@options[:display_style_guide] ||
             config['AllCops'] && config['AllCops']['DisplayStyleGuide'])
       end
 
+      def extra_details?
+        @options[:extra_details] ||
+          config['AllCops'] && config['AllCops']['ExtraDetails']
+      end
+
       # Returns true if the cop name or the cop namespace matches any of the
       # given names.
       def self.match?(given_names)
@@ -154,34 +160,33 @@ module RuboCop
       def add_offense(node, loc, message = nil, severity = nil)
         location = loc.is_a?(Symbol) ? node.loc.send(loc) : loc
 
-        return unless enabled_line?(location.line)
-
         # Don't include the same location twice for one cop.
-        return if @offenses.find { |o| o.location == location }
+        return if @offenses.any? { |o| o.location == location }
 
         severity = custom_severity || severity || default_severity
 
         message ||= message(node)
         message = annotate_message(message)
 
-        corrected = correct(node)
+        status = enabled_line?(location.line) ? correct(node) : :disabled
 
-        @offenses << Offense.new(severity, location, message, name, corrected)
-        yield if block_given?
+        @offenses << Offense.new(severity, location, message, name, status)
+        yield if block_given? && status != :disabled
       end
 
       def correct(node)
-        return nil unless support_autocorrect?
-        return false unless autocorrect?
+        return :unsupported unless support_autocorrect?
+        return :uncorrected unless autocorrect?
 
         correction = autocorrect(node)
-        return false unless correction
+        return :uncorrected unless correction
         @corrections << correction
-        true
+        :corrected
       end
 
       def config_to_allow_offenses
-        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name]
+        Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses[cop_name] ||= {}
       end
 
       def config_to_allow_offenses=(hash)
@@ -200,21 +205,39 @@ module RuboCop
           !file_name_matches_any?(file, 'Exclude', false)
       end
 
+      def excluded_file?(file)
+        !relevant_file?(file)
+      end
+
       def style_guide_url
-        url = cop_config && cop_config['StyleGuide']
+        url = cop_config['StyleGuide']
         (url.nil? || url.empty?) ? nil : url
       end
 
+      def reference_url
+        url = cop_config['Reference']
+        (url.nil? || url.empty?) ? nil : url
+      end
+
+      def details
+        details = cop_config && cop_config['Details']
+        (details.nil? || details.empty?) ? nil : details
+      end
+
       private
 
       def annotate_message(message)
         message = "#{name}: #{message}" if display_cop_names?
-        message = "#{message} (#{style_guide_url})" if display_style_guide?
+        message += " #{details}" if extra_details?
+        if display_style_guide?
+          links = [style_guide_url, reference_url].compact.join(', ')
+          message = "#{message} (#{links})"
+        end
         message
       end
 
       def file_name_matches_any?(file, parameter, default_result)
-        patterns = cop_config && cop_config[parameter]
+        patterns = cop_config[parameter]
         return default_result unless patterns
         path = nil
         patterns.any? do |pattern|
@@ -237,15 +260,15 @@ module RuboCop
       end
 
       def custom_severity
-        severity = cop_config && cop_config['Severity']
+        severity = cop_config['Severity']
         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))
+          message = "Warning: Invalid severity '#{severity}'. " \
+            "Valid severities are #{Severity::NAMES.join(', ')}."
+          warn(Rainbow(message).red)
         end
       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 on_block(node)
           return if ignored_node?(node)

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for circular argument references in optional keyword
+      # arguments and optional ordinal arguments.
+      #
+      # This cop mirrors a warning produced by MRI since 2.2.
+      #
+      # @example
+      #   # bad
+      #   def bake(pie: pie)
+      #     pie.heat_up
+      #   end
+      #
+      #   # good
+      #   def bake(pie:)
+      #     pie.refrigerate
+      #   end
+      #
+      #   # good
+      #   def bake(pie: self.pie)
+      #     pie.feed_to(user)
+      #   end
+      #
+      #   # bad
+      #   def cook(dry_ingredients = dry_ingredients)
+      #     dry_ingredients.reduce(&:+)
+      #   end
+      #
+      #   # good
+      #   def cook(dry_ingredients = self.dry_ingredients)
+      #     dry_ingredients.combine
+      #   end
+      class CircularArgumentReference < Cop
+        MSG = 'Circular argument reference - `%s`.'
+
+        def on_kwoptarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        def on_optarg(node)
+          check_for_circular_argument_references(*node)
+        end
+
+        private
+
+        def check_for_circular_argument_references(arg_name, arg_value)
+          case arg_value.type
+          when :send
+            # Ruby 2.0 will have type send every time, and "send nil" if it is
+            # calling itself with a specified "self" receiver
+            receiver, name = *arg_value
+            return unless name == arg_name && receiver.nil?
+          when :lvar
+            # Ruby 2.2.2 will have type lvar if it is calling its own method
+            # without a specified "self"
+            return unless arg_value.to_a == [arg_name]
+          else
+            return
+          end
+
+          add_offense(arg_value, :expression, format(MSG, arg_name))
+        end
+      end
+    end
+  end
+end

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

@@ -7,56 +7,17 @@ module RuboCop
       class Debugger < Cop
         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
-        #   (send nil :binding) :pry)
-        PRY_NODE = s(:send, s(:send, nil, :binding), :pry)
-
-        # binding.remote_pry node
-        #
-        # (send
-        #   (send nil :binding) :remote_pry)
-        REMOTE_PRY_NODE = s(:send, s(:send, nil, :binding), :remote_pry)
-
-        # binding.pry_remote node
-        #
-        # (send
-        #   (send nil :binding) :pry_remote)
-        PRY_REMOTE_NODE = s(:send, s(:send, nil, :binding), :pry_remote)
-
-        # save_and_open_page
-        #
-        # (send nil :save_and_open_page)
-        CAPYBARA_SAVE_PAGE = s(:send, nil, :save_and_open_page)
-
-        # save_and_open_screenshot
-        #
-        # (send nil :save_and_open_screenshot)
-        CAPYBARA_SAVE_SCREENSHOT = s(:send, nil, :save_and_open_screenshot)
-
-        DEBUGGER_NODES = [
-          DEBUGGER_NODE,
-          BYEBUG_NODE,
-          PRY_NODE,
-          REMOTE_PRY_NODE,
-          PRY_REMOTE_NODE,
-          CAPYBARA_SAVE_PAGE,
-          CAPYBARA_SAVE_SCREENSHOT
-        ]
+        def_node_matcher :debugger_call?,
+                         '{(send nil {:debugger :byebug} ...)
+                           (send (send nil :binding)
+                             {:pry :remote_pry :pry_remote} ...)
+                           (send (const nil :Pry) :rescue ...)
+                           (send nil {:save_and_open_page
+                                      :save_and_open_screenshot
+                                      :save_screenshot} ...)}'
 
         def on_send(node)
-          return unless DEBUGGER_NODES.include?(node)
+          return unless debugger_call?(node)
           add_offense(node,
                       :expression,
                       format(MSG, node.loc.expression.source))

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

@@ -20,7 +20,7 @@ module RuboCop
         include OnMethodDef
         include EndKeywordAlignment
 
-        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_method_def(node, _method_name, _args, _body)
           check_offset_of_node(node)
@@ -28,8 +28,8 @@ module RuboCop
 
         def on_send(node)
           receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
+          return unless modifier_and_def_on_same_line?(receiver, method_name,
+                                                       args)
 
           method_def = args.first
           if style == :start_of_line
@@ -49,7 +49,11 @@ module RuboCop
         private
 
         def autocorrect(node)
-          align(node, style == :start_of_line ? node.ancestors.first : node)
+          if style == :start_of_line && node.parent && node.parent.send_type?
+            align(node, node.parent)
+          else
+            align(node, node)
+          end
         end
       end
     end

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

@@ -5,22 +5,36 @@ module RuboCop
     module Lint
       # This cop checks for uses of the deprecated class method usages.
       class DeprecatedClassMethods < Cop
-        include AST::Sexp
+        # Inner class to DeprecatedClassMethods.
+        # This class exists to add abstraction and clean naming to the
+        # objects that are going to be operated on.
+        class DeprecatedClassMethod
+          include AST::Sexp
 
-        MSG = '`%s` is deprecated in favor of `%s`.'
+          attr_reader :class_constant, :deprecated_method, :replacement_method
 
-        DEPRECATED_METHODS = [
-          [:File, :exists?, :exist?],
-          [:Dir, :exists?, :exist?]
-        ]
+          def initialize(class_constant, deprecated_method, replacement_method)
+            @class_constant = class_constant
+            @deprecated_method = deprecated_method
+            @replacement_method = replacement_method
+          end
 
-        def on_send(node)
-          receiver, method_name, *_args = *node
+          def class_nodes
+            @class_nodes ||= [
+              s(:const, nil, class_constant),
+              s(:const, s(:cbase), class_constant)
+            ]
+          end
+        end
 
-          DEPRECATED_METHODS.each do |data|
-            next unless class_nodes(data).include?(receiver)
-            next unless method_name == data[1]
+        MSG = '`%s` is deprecated in favor of `%s`.'
+        DEPRECATED_METHODS_OBJECT = [
+          DeprecatedClassMethod.new(:File, :exists?, :exist?),
+          DeprecatedClassMethod.new(:Dir, :exists?, :exist?)
+        ]
 
+        def on_send(node)
+          check(node) do |data|
             add_offense(node, :selector,
                         format(MSG,
                                deprecated_method(data),
@@ -30,31 +44,36 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            receiver, method_name, *_args = *node
-
-            DEPRECATED_METHODS.each do |data|
-              next unless class_nodes(data).include?(receiver)
-              next unless method_name == data[1]
-
+            check(node) do |data|
               corrector.replace(node.loc.selector,
-                                data[2].to_s)
+                                data.replacement_method.to_s)
             end
           end
         end
 
         private
 
-        def class_nodes(data)
-          [s(:const, nil, data[0]),
-           s(:const, s(:cbase), data[0])]
+        def check(node, &block)
+          receiver, method_name, *_args = *node
+
+          DEPRECATED_METHODS_OBJECT.each do |data|
+            next unless data.class_nodes.include?(receiver)
+            next unless method_name == data.deprecated_method
+
+            block.call(data)
+          end
         end
 
         def deprecated_method(data)
-          format('%s.%s', data[0], data[1])
+          method_call(data.class_constant, data.deprecated_method)
         end
 
         def replacement_method(data)
-          format('%s.%s', data[0], data[2])
+          method_call(data.class_constant, data.replacement_method)
+        end
+
+        def method_call(class_constant, method)
+          format('%s.%s', class_constant, method)
         end
       end
     end

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

@@ -65,7 +65,7 @@ module RuboCop
 
         def method_names(body)
           body.child_nodes.map do |node|
-            _receiver, node, body  = *node if node.send_type?
+            _receiver, node, body = *node if node.send_type?
 
             if node.is_a? Symbol
               next if body.nil?
@@ -76,7 +76,7 @@ module RuboCop
               method, _args, _body = *node
             elsif node.defs_type?
               _receiver, method = *node
-              method = "self.#{ method }"
+              method = "self.#{method}"
             end
 
             method ? [method, node] : nil

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicated keys in hash literals.
+      #
+      # This cop mirrors a warning in Ruby 2.2.
+      #
+      # @example
+      #   hash = { food: 'apple', food: 'orange' }
+      class DuplicatedKey < Cop
+        MSG = 'Duplicated key in hash literal.'
+
+        LITERALS = [:sym, :str, :float, :int]
+
+        def on_hash(node)
+          keys = []
+
+          hash_pairs = *node
+          hash_pairs.each do |pair|
+            key, _value = *pair
+            if keys.include?(key) && LITERALS.include?(key.type)
+              add_offense(key, :expression)
+            elsif keys.include?(key) && key.type == :array
+              key.children.each do |child|
+                return false unless LITERALS.include?(child.type)
+              end
+              add_offense(key, :expression)
+            end
+            keys << key
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -40,6 +40,14 @@ module RuboCop
           check_offset_of_node(node)
         end
 
+        def on_case(node)
+          if argument_case?(node)
+            return check_alignment(node.ancestors.first, node)
+          end
+
+          check_offset_of_node(node)
+        end
+
         private
 
         def check_assignment(node, rhs)
@@ -50,31 +58,43 @@ module RuboCop
 
           return unless rhs
 
-          return unless [:if, :while, :until].include?(rhs.type)
+          return unless [:if, :while, :until, :case].include?(rhs.type)
           return if ternary_op?(rhs)
 
-          expr = node.loc.expression
-          if style == :variable && !line_break_before_keyword?(expr, rhs)
+          check_alignment(node, rhs)
+        end
+
+        def check_alignment(outer_node, inner_node)
+          expr = outer_node.loc.expression
+          if variable_alignment?(expr, inner_node, style)
             range = Parser::Source::Range.new(expr.source_buffer,
                                               expr.begin_pos,
-                                              rhs.loc.keyword.end_pos)
-            offset = rhs.loc.keyword.column - node.loc.expression.column
+                                              inner_node.loc.keyword.end_pos)
+            offset =
+              inner_node.loc.keyword.column - outer_node.loc.expression.column
           else
-            range = rhs.loc.keyword
+            range = inner_node.loc.keyword
             offset = 0
           end
 
-          check_offset(rhs, range.source, offset)
-          ignore_node(rhs) # Don't check again.
+          check_offset(inner_node, range.source, offset)
+          ignore_node(inner_node) # Don't check again.
         end
 
-        def line_break_before_keyword?(whole_expression, rhs)
-          rhs.loc.keyword.line > whole_expression.line
+        def autocorrect(node)
+          align(node, alignment_node(node))
         end
 
-        def autocorrect(node)
-          align(node,
-                style == :variable ? node.each_ancestor(:lvasgn).first : node)
+        def alignment_node(node)
+          return node unless style == :variable
+          return node.ancestors.first if argument_case?(node)
+
+          node.each_ancestor(:lvasgn).first
+        end
+
+        def argument_case?(node)
+          node.case_type? && !node.ancestors.empty? &&
+            node.ancestors.first.send_type?
         end
       end
     end

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

@@ -8,9 +8,13 @@ module RuboCop
         MSG = 'The use of `eval` is a serious security risk.'
 
         def on_send(node)
-          receiver, method_name, = *node
+          receiver, method_name, *args = *node
 
-          add_offense(node, :selector) if receiver.nil? && method_name == :eval
+          return unless receiver.nil? &&
+                        method_name == :eval &&
+                        !args.empty? &&
+                        args.first.type != :str
+          add_offense(node, :selector)
         end
       end
     end