rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,46 +8,58 @@ 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
-
         MSG = 'Useless setter call to local variable `%s`.'.freeze
-        ASSIGNMENT_TYPES = [:lvasgn, :ivasgn, :cvasgn, :gvasgn].freeze
+        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
 
-        private
-
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          expression = if body.type == :begin
-                         body.children
-                       else
-                         body
-                       end
-
-          last_expr = expression.is_a?(Array) ? expression.last : expression
+        def on_def(node)
+          return unless node.body
 
+          last_expr = last_expression(node.body)
           return unless setter_call_to_local_variable?(last_expr)
 
-          tracker = MethodVariableTracker.new(body)
+          tracker = MethodVariableTracker.new(node.body)
           receiver, = *last_expr
           variable_name, = *receiver
           return unless tracker.contain_local_object?(variable_name)
 
-          add_offense(receiver,
-                      :name,
-                      format(MSG, receiver.loc.name.source))
+          add_offense(
+            receiver,
+            location: :name,
+            message: format(MSG, receiver.loc.name.source)
+          )
+        end
+        alias on_defs on_def
+
+        private
+
+        def last_expression(body)
+          expression = body.begin_type? ? body.children : body
+
+          expression.is_a?(Array) ? expression.last : expression
         end
 
         def setter_call_to_local_variable?(node)
-          return unless node && node.type == :send
-          receiver, method, _args = *node
-          return unless receiver && receiver.type == :lvar
-          method =~ /(?:\w|\[\])=$/
+          return unless node && node.send_type?
+          return unless node.receiver && node.receiver.lvar_type?
+
+          node.method_name =~ /(?:\w|\[\])=$/
         end
 
         # This class tracks variable assignments in a method body
@@ -57,6 +68,7 @@ module RuboCop
         class MethodVariableTracker
           def initialize(body_node)
             @body_node = body_node
+            @local = nil
           end
 
           def contain_local_object?(variable_name)
@@ -64,19 +76,7 @@ module RuboCop
 
             @local = {}
 
-            scan(@body_node) do |node|
-              case node.type
-              when :masgn
-                process_multiple_assignment(node)
-              when :or_asgn, :and_asgn
-                process_logical_operator_assignment(node)
-              when :op_asgn
-                process_binary_operator_assignment(node)
-              when *ASSIGNMENT_TYPES
-                _, rhs_node = *node
-                process_assignment(node, rhs_node) if rhs_node
-              end
-            end
+            scan(@body_node) { |node| process_assignment_node(node) }
 
             @local[variable_name]
           end
@@ -91,6 +91,20 @@ module RuboCop
             end
           end
 
+          def process_assignment_node(node)
+            case node.type
+            when :masgn
+              process_multiple_assignment(node)
+            when :or_asgn, :and_asgn
+              process_logical_operator_assignment(node)
+            when :op_asgn
+              process_binary_operator_assignment(node)
+            when *ASSIGNMENT_TYPES
+              _, rhs_node = *node
+              process_assignment(node, rhs_node) if rhs_node
+            end
+          end
+
           def process_multiple_assignment(masgn_node)
             mlhs_node, mrhs_node = *masgn_node
 
@@ -100,7 +114,7 @@ module RuboCop
               lhs_variable_name, = *lhs_node
               rhs_node = mrhs_node.children[index]
 
-              if mrhs_node.type == :array && rhs_node
+              if mrhs_node.array_type? && rhs_node
                 process_assignment(lhs_variable_name, rhs_node)
               else
                 @local[lhs_variable_name] = true
@@ -140,7 +154,7 @@ module RuboCop
 
           def constructor?(node)
             return true if node.literal?
-            return false unless node.type == :send
+            return false unless node.send_type?
             _receiver, method = *node
             method == :new
           end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,52 +5,113 @@ 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)
+      #     some_var
+      #     do_something
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     do_something
+      #     some_num * 10
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method(some_var)
+      #     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
+        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
+        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
+        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
+        VOID_CONTEXT_TYPES = %i[def for block].freeze
 
         def on_begin(node)
           check_begin(node)
         end
-
-        def on_kwbegin(node)
-          check_begin(node)
-        end
+        alias on_kwbegin on_begin
 
         private
 
         def check_begin(node)
           expressions = *node
-
-          expressions.drop_last(1).each do |expr|
-            check_for_void_op(expr)
-            check_for_literal(expr)
-            check_for_var(expr)
+          expressions = expressions.drop_last(1) unless in_void_context?(node)
+          expressions.each do |expr|
+            check_void_op(expr)
+            check_literal(expr)
+            check_var(expr)
+            check_self(expr)
+            check_defined(expr)
           end
         end
 
-        def check_for_void_op(node)
-          return unless node.type == :send
-          return unless node.loc.selector
+        def check_void_op(node)
+          return unless node.send_type? && OPERATORS.include?(node.method_name)
 
-          op = node.loc.selector.source
-
-          add_offense(node, :selector, format(OP_MSG, op)) if OPS.include?(op)
+          add_offense(node,
+                      location: :selector,
+                      message: format(OP_MSG, node.method_name))
         end
 
-        def check_for_var(node)
+        def check_var(node)
           return unless node.variable? || node.const_type?
-          add_offense(node, :name, format(VAR_MSG, node.loc.name.source))
+
+          add_offense(node,
+                      location: :name,
+                      message: format(VAR_MSG, node.loc.name.source))
+        end
+
+        def check_literal(node)
+          return if !node.literal? || node.xstr_type?
+
+          add_offense(node, message: format(LIT_MSG, node.source))
+        end
+
+        def check_self(node)
+          return unless node.self_type?
+
+          add_offense(node, message: SELF_MSG)
         end
 
-        def check_for_literal(node)
-          return unless node.literal?
-          return if node.xstr_type?
+        def check_defined(node)
+          return unless node.defined_type?
+
+          add_offense(node, message: format(DEFINED_MSG, node.source))
+        end
+
+        def in_void_context?(node)
+          parent = node.parent
+
+          return false unless parent && parent.children.last == node
 
-          add_offense(node, :expression, format(LIT_MSG, node.source))
+          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
         end
       end
     end

data/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,118 @@
+# 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
+
+      @style_guide_urls = {}
+
+      class << self
+        attr_reader :style_guide_urls
+      end
+
+      # @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, nil] options optional
+      # @option options [Boolean] :display_style_guide
+      #   Include style guide and reference URLs
+      # @option options [Boolean] :extra_details
+      #   Include cop specific details
+      # @option options [Boolean] :debug
+      #   Include debug output
+      # @option options [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? && details
+        if display_style_guide?
+          links = urls.join(', ')
+          message = "#{message} (#{links})"
+        end
+        message
+      end
+
+      def urls
+        [style_guide_url, reference_url].compact
+      end
+
+      private
+
+      def style_guide_url
+        url = cop_config['StyleGuide']
+        return nil if url.nil? || url.empty?
+
+        self.class.style_guide_urls[url] ||= begin
+          base_url = config.for_all_cops['StyleGuideBaseURL']
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
+      end
+
+      def display_style_guide?
+        (options[:display_style_guide] ||
+         config.for_all_cops['DisplayStyleGuide']) &&
+          !urls.empty?
+      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?
+        return true if debug?
+        return false if options[:display_cop_names] == false
+        return true if 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/abc_size.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -10,9 +9,9 @@ module RuboCop
       class AbcSize < Cop
         include MethodComplexity
 
-        MSG = 'Assignment Branch Condition size for %s is too high. ' \
-              '[%.4g/%.4g]'.freeze
-        BRANCH_NODES = [:send].freeze
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<complexity>.4g/%<max>.4g]'.freeze
+        BRANCH_NODES = %i[send csend].freeze
         CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
 
         private

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # 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.send_node.method_name.to_s)
+          check_code_length(node)
+        end
+
+        private
+
+        def excluded_methods
+          cop_config['ExcludedMethods'] || []
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

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

@@ -1,21 +1,22 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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,
-          :until, :until_post, :for, :resbody
+        NESTING_BLOCKS = %i[
+          case if while while_post
+          until until_post for resbody
         ].freeze
 
         def investigate(processed_source)
@@ -27,12 +28,12 @@ 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)
-                add_offense(node, :expression, message(max)) do
+                add_offense(node, message: message(max)) do
                   ignore_node(node)
                 end
               end
@@ -44,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

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,7 +16,9 @@ module RuboCop
         private
 
         def message(length, max_length)
-          format('Class has too many lines. [%d/%d]', length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,9 +16,10 @@ module RuboCop
       class CyclomaticComplexity < Cop
         include MethodComplexity
 
-        MSG = 'Cyclomatic complexity for %s is too high. [%d/%d]'.freeze
-        COUNTED_NODES = [:if, :while, :until, :for,
-                         :rescue, :when, :and, :or].freeze
+        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'.freeze
+        COUNTED_NODES = %i[if while until for
+                           rescue when and or].freeze
 
         private
 

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'uri'
@@ -10,8 +9,9 @@ module RuboCop
       # The maximum length is configurable.
       class LineLength < Cop
         include ConfigurableMax
+        include IgnoredPattern
 
-        MSG = 'Line is too long. [%d/%d]'.freeze
+        MSG = 'Line is too long. [%<length>d/%<max>d]'.freeze
 
         def investigate(processed_source)
           heredocs = extract_heredocs(processed_source.ast) if allow_heredoc?
@@ -20,22 +20,34 @@ module RuboCop
           end
         end
 
+        private
+
         def check_line(line, index, heredocs)
-          return unless line.length > max
-          return if heredocs &&
-                    line_in_whitelisted_heredoc?(heredocs, index.succ)
+          return if line.length <= max
+          return if ignored_line?(line, index, heredocs)
 
-          if allow_uri?
-            uri_range = find_excessive_uri_range(line)
-            return if uri_range && allowed_uri_position?(line, uri_range)
+          if ignore_cop_directives? && directive_on_source_line?(index)
+            return check_directive_line(line, index)
           end
+          return check_uri_line(line, index) if allow_uri?
+
+          register_offense(
+            source_range(processed_source.buffer, index + 1, 0...line.length),
+            line
+          )
+        end
 
-          offense(excess_range(uri_range, line, index), line)
+        def ignored_line?(line, index, heredocs)
+          matches_ignored_pattern?(line) ||
+            heredocs && line_in_whitelisted_heredoc?(heredocs, index.succ)
         end
 
-        def offense(loc, line)
-          message = format(MSG, line.length, max)
-          add_offense(nil, loc, message) { self.max = line.length }
+        def register_offense(loc, line)
+          message = format(MSG, length: line.length, max: max)
+
+          add_offense(nil, location: loc, message: message) do
+            self.max = line.length
+          end
         end
 
         def excess_range(uri_range, line, index)
@@ -82,6 +94,10 @@ module RuboCop
           cop_config['AllowURI']
         end
 
+        def ignore_cop_directives?
+          cop_config['IgnoreCopDirectives']
+        end
+
         def allowed_uri_position?(line, uri_range)
           uri_range.begin < max && uri_range.end == line.length
         end
@@ -105,12 +121,49 @@ module RuboCop
         def valid_uri?(uri_ish_string)
           URI.parse(uri_ish_string)
           true
-        rescue
+        rescue URI::InvalidURIError, NoMethodError
           false
         end
 
         def uri_regexp
-          @regexp ||= URI.regexp(cop_config['URISchemes'])
+          @regexp ||= URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
+        end
+
+        def check_directive_line(line, index)
+          return if line_length_without_directive(line) <= max
+
+          range = max..(line_length_without_directive(line) - 1)
+          register_offense(
+            source_range(
+              processed_source.buffer,
+              index + 1,
+              range
+            ),
+            line
+          )
+        end
+
+        def directive_on_source_line?(index)
+          source_line_number = index + processed_source.buffer.first_line
+          comment =
+            processed_source
+            .comments
+            .detect { |e| e.location.line == source_line_number }
+
+          return false unless comment
+          comment.text.match(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        end
+
+        def line_length_without_directive(line)
+          before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+          before_comment.rstrip.length
+        end
+
+        def check_uri_line(line, index)
+          uri_range = find_excessive_uri_range(line)
+          return if uri_range && allowed_uri_position?(line, uri_range)
+
+          register_offense(excess_range(uri_range, line, index), line)
         end
       end
     end