rubocop 0.46.0 → 0.47.0

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

@@ -159,7 +159,7 @@ module RuboCop
 
         def cop_range(comment, cop)
           matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, cop.split('/').last) ||
+            matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
@@ -199,7 +199,7 @@ module RuboCop
         end
 
         def all_cop_names
-          @all_cop_names ||= Cop.all.map(&:cop_name)
+          @all_cop_names ||= Cop.registry.names
         end
       end
     end

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

@@ -6,7 +6,9 @@ module RuboCop
       # This cop checks for unneeded usages of splat expansion
       #
       # @example
+      #
       #   # bad
+      #
       #   a = *[1, 2, 3]
       #   a = *'a'
       #   a = *1
@@ -24,7 +26,10 @@ module RuboCop
       #     baz
       #   end
       #
+      # @example
+      #
       #   # good
+      #
       #   c = [1, 2, 3]
       #   a = *c
       #   a, b = *c

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

@@ -6,6 +6,23 @@ module RuboCop
       # This cop checks for unreachable code.
       # The check are based on the presence of flow of control
       # statement in non-final position in *begin*(implicit) blocks.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     return
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #   end
       class UnreachableCode < Cop
         MSG = 'Unreachable code detected.'.freeze
 

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

@@ -21,6 +21,8 @@ module RuboCop
       #     puts :baz
       #   end
       #
+      # @example
+      #
       #   # bad
       #
       #   do_something do |used, _unused|

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

@@ -7,9 +7,19 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   def some_method(used, unused, _unused_but_allowed)
       #     puts used
       #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method(used, _unused, _unused_but_allowed)
+      #     puts used
+      #   end
       class UnusedMethodArgument < Cop
         include UnusedArgument
 

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

@@ -78,6 +78,18 @@ module RuboCop
       #     def some_other_private_method
       #     end
       #   end
+      #
+      # @example
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
       class UselessAccessModifier < Cop
         MSG = 'Useless `%s` access modifier.'.freeze
 
@@ -170,7 +182,22 @@ module RuboCop
         end
 
         def method_definition?(child)
-          static_method_definition?(child) || dynamic_method_definition?(child)
+          static_method_definition?(child) ||
+            dynamic_method_definition?(child) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            matcher_name = "#{m}_method?".to_sym
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<-PATTERN
+                {def (send nil :#{m} ...)}
+              PATTERN
+            end
+
+            send(matcher_name, child)
+          end
         end
 
         def start_of_new_scope?(child)

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

@@ -12,6 +12,24 @@ module RuboCop
       # Currently this cop has advanced logic that detects unreferenced
       # reassignments and properly handles varied cases such as branch, loop,
       # rescue, ensure, etc.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     some_var = 1
+      #     do_something(some_var)
+      #   end
       class UselessAssignment < Cop
         include NameSimilarity
         MSG = 'Useless assignment to variable - `%s`.'.freeze

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

@@ -7,7 +7,9 @@ module RuboCop
       #
       # @example
       #
-      #  x.top >= x.top
+      #   # bad
+      #
+      #   x.top >= x.top
       class UselessComparison < Cop
         MSG = 'Comparison of something with itself detected.'.freeze
         OPS = %w(== === != < > <= >= <=>).freeze

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

@@ -6,10 +6,25 @@ module RuboCop
       # This cop checks for useless `else` in `begin..end` without `rescue`.
       #
       # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   else
+      #     do_something_else # This will never be run.
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
       #   begin
       #     do_something
+      #   rescue
+      #     handle_errors
       #   else
-      #     handle_errors # This will never be run.
+      #     do_something_else
       #   end
       class UselessElseWithoutRescue < Cop
         include ParserDiagnostic

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

@@ -8,10 +8,22 @@ module RuboCop
       #
       # @example
       #
-      #  def something
-      #    x = Something.new
-      #    x.attr = 5
-      #  end
+      #   # bad
+      #
+      #   def something
+      #     x = Something.new
+      #     x.attr = 5
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def something
+      #     x = Something.new
+      #     x.attr = 5
+      #     x
+      #   end
       class UselessSetterCall < Cop
         include OnMethodDef
 

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

@@ -5,10 +5,48 @@ module RuboCop
     module Lint
       # This cop checks for operators, variables and literals used
       # in void context.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_num * 10
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #     some_var
+      #   end
       class Void < Cop
         OP_MSG = 'Operator `%s` used in void context.'.freeze
         VAR_MSG = 'Variable `%s` used in void context.'.freeze
         LIT_MSG = 'Literal `%s` used in void context.'.freeze
+        SELF_MSG = '`self` used in void context.'.freeze
+        DEFINED_MSG = '`%s` used in void context.'.freeze
 
         OPS = %w(* / % + - == === != < > <= >= <=>).freeze
 
@@ -29,6 +67,8 @@ module RuboCop
             check_for_void_op(expr)
             check_for_literal(expr)
             check_for_var(expr)
+            check_for_self(expr)
+            check_for_defined(expr)
           end
         end
 
@@ -50,6 +90,18 @@ module RuboCop
 
           add_offense(node, :expression, format(LIT_MSG, node.source))
         end
+
+        def check_for_self(node)
+          return unless node.self_type?
+
+          add_offense(node, :expression, SELF_MSG)
+        end
+
+        def check_for_defined(node)
+          return unless node.defined_type?
+
+          add_offense(node, :expression, format(DEFINED_MSG, node.source))
+        end
       end
     end
   end

data/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Message Annotator class annotates a basic offense message
+    # based on params passed into initializer.
+    #
+    # @see #initialize
+    #
+    # @example
+    #   RuboCop::Cop::MessageAnnotator.new(
+    #     config, cop_config, @options
+    #   ).annotate('message', 'Cop/CopName')
+    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+    class MessageAnnotator
+      attr_reader :options, :config, :cop_config
+
+      # @param config [RuboCop::Config] Check configs for all cops
+      #   @note Message Annotator specifically checks the
+      #     following config options for_all_cops
+      #     :StyleGuideBaseURL [String] URL for styleguide
+      #     :DisplayStyleGuide [Boolean] Include styleguide and reference URLs
+      #     :ExtraDetails [Boolean] Include cop details
+      #     :DisplayCopNames [Boolean] Include cop name
+      #
+      # @param [Hash] cop_config configs for specific cop, from config#for_cop
+      # @option cop_config [String] :StyleGuide Extension of base styleguide URL
+      # @option cop_config [String] :Reference Full reference URL
+      # @option cop_config [String] :Details
+      #
+      # @param [Hash] options
+      # @option option [Boolean] :display_style_guide
+      #   Include style guide and reference URLs
+      # @option option [Boolean] :extra_details
+      #   Include cop specific details
+      # @option option [Boolean] :debug
+      #   Include debug output
+      # @option option [Boolean] :display_cop_names
+      #   Include cop name
+      def initialize(config, cop_config, options)
+        @config = config
+        @cop_config = cop_config || {}
+        @options = options
+      end
+
+      # Returns the annotated message,
+      # based on params passed into initializer
+      #
+      # @return [String] annotated message
+      def annotate(message, name)
+        message = "#{name}: #{message}" if display_cop_names?
+        message += " #{details}" if extra_details?
+        if display_style_guide?
+          links = [style_guide_url, reference_url].compact.join(', ')
+          message = "#{message} (#{links})"
+        end
+        message
+      end
+
+      private
+
+      def style_guide_url
+        url = cop_config['StyleGuide']
+        return nil if url.nil? || url.empty?
+
+        base_url = config.for_all_cops['StyleGuideBaseURL']
+        return url if base_url.nil? || base_url.empty?
+
+        URI.join(base_url, url).to_s
+      end
+
+      def display_style_guide?
+        (style_guide_url || reference_url) &&
+          (options[:display_style_guide] ||
+            config.for_all_cops['DisplayStyleGuide'])
+      end
+
+      def reference_url
+        url = cop_config['Reference']
+        url.nil? || url.empty? ? nil : url
+      end
+
+      def extra_details?
+        options[:extra_details] || config.for_all_cops['ExtraDetails']
+      end
+
+      def debug?
+        options[:debug]
+      end
+
+      def display_cop_names?
+        debug? || options[:display_cop_names] ||
+          config.for_all_cops['DisplayCopNames']
+      end
+
+      def details
+        details = cop_config && cop_config['Details']
+        details.nil? || details.empty? ? nil : details
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/block_length.rb

@@ -6,17 +6,23 @@ module RuboCop
       # This cop checks if the length of a block exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
+      # The cop can be configured to ignore blocks passed to certain methods.
       class BlockLength < Cop
         include TooManyLines
 
         LABEL = 'Block'.freeze
 
         def on_block(node)
+          return if excluded_methods.include?(node.method_name.to_s)
           check_code_length(node)
         end
 
         private
 
+        def excluded_methods
+          cop_config['ExcludedMethods'] || []
+        end
+
         def cop_label
           LABEL
         end

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

@@ -4,13 +4,15 @@ module RuboCop
   module Cop
     module Metrics
       # This cop checks for excessive nesting of conditional and looping
-      # constructs. Despite the cop's name, blocks are not considered as an
-      # extra level of nesting.
+      # constructs.
+      #
+      # You can configure if blocks are considered using the `CountBlocks`
+      # option. When set to `false` (the default) blocks are not counted
+      # towards the nesting level. Set to `true` to count blocks as well.
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Cop
         include ConfigurableMax
-        include IfNode
 
         NESTING_BLOCKS = [
           :case, :if, :while, :while_post,
@@ -26,8 +28,8 @@ module RuboCop
         private
 
         def check_nesting_level(node, max, current_level)
-          if NESTING_BLOCKS.include?(node.type)
-            current_level += 1 unless elsif?(node)
+          if consider_node?(node)
+            current_level += 1 unless node.if_type? && node.elsif?
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)
@@ -43,9 +45,19 @@ module RuboCop
           end
         end
 
+        def consider_node?(node)
+          return true if NESTING_BLOCKS.include?(node.type)
+
+          count_blocks? && node.block_type?
+        end
+
         def message(max)
           "Avoid more than #{max} levels of block nesting."
         end
+
+        def count_blocks?
+          cop_config['CountBlocks']
+        end
       end
     end
   end