rubocop 0.75.1

data/lib/rubocop/cop/message_annotator.rb

@@ -0,0 +1,129 @@
+# 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_name, cop_config, @options
+    #   ).annotate('message')
+    #  #=> 'Cop/CopName: message (http://example.org/styleguide)'
+    class MessageAnnotator
+      attr_reader :options, :config, :cop_name, :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 [String] cop_name for specific 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_name, cop_config, options)
+        @config = config
+        @cop_name = cop_name
+        @cop_config = cop_config || {}
+        @options = options
+      end
+
+      # Returns the annotated message,
+      # based on params passed into initializer
+      #
+      # @return [String] annotated message
+      def annotate(message)
+        message = "#{cop_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_urls].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 = style_guide_base_url
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
+      end
+
+      def style_guide_base_url
+        department_name = cop_name.split('/').first
+
+        config.for_department(department_name)['StyleGuideBaseURL'] ||
+          config.for_all_cops['StyleGuideBaseURL']
+      end
+
+      def display_style_guide?
+        (options[:display_style_guide] ||
+         config.for_all_cops['DisplayStyleGuide']) &&
+          !urls.empty?
+      end
+
+      def reference_urls
+        urls = Array(cop_config['Reference'])
+        urls.nil? || urls.empty? ? nil : urls.reject(&:empty?)
+      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]
+        return false if options[:format] == 'json'
+
+        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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks that the ABC size of methods is not higher than the
+      # configured maximum. The ABC size is based on assignments, branches
+      # (method calls), and conditions. See http://c2.com/cgi/wiki?AbcMetric
+      # and https://en.wikipedia.org/wiki/ABC_Software_Metric.
+      class AbcSize < Cop
+        include MethodComplexity
+
+        MSG = 'Assignment Branch Condition size for %<method>s is too high. ' \
+              '[%<complexity>.4g/%<max>.4g]'
+
+        private
+
+        def complexity(node)
+          Utils::AbcSizeCalculator.calculate(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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'
+
+        def on_block(node)
+          return if excluded_method?(node)
+          return if node.class_constructor?
+
+          check_code_length(node)
+        end
+
+        private
+
+        def excluded_method?(node)
+          node_receiver = node.receiver&.source&.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          excluded_methods.any? do |config|
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
+        def excluded_methods
+          cop_config['ExcludedMethods'] || []
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks for excessive nesting of conditional and looping
+      # 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
+
+        NESTING_BLOCKS = %i[
+          case if while while_post
+          until until_post for resbody
+        ].freeze
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          max = cop_config['Max']
+          check_nesting_level(processed_source.ast, max, 0)
+        end
+
+        private
+
+        def check_nesting_level(node, max, current_level)
+          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, message: message(max)) do
+                  ignore_node(node)
+                end
+              end
+            end
+          end
+
+          node.each_child_node do |child_node|
+            check_nesting_level(child_node, max, current_level)
+          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
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks if the length a class exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      # The maximum allowed length is configurable.
+      class ClassLength < Cop
+        include ClassishLength
+
+        def on_class(node)
+          check_code_length(node)
+        end
+
+        def on_casgn(node)
+          class_definition?(node) do
+            check_code_length(node)
+          end
+        end
+
+        private
+
+        def_node_matcher :class_definition?, <<~PATTERN
+          (casgn nil? _ (block (send (const nil? :Class) :new) ...))
+        PATTERN
+
+        def message(length, max_length)
+          format('Class has too many lines. [%<length>d/%<max>d]',
+                 length: length,
+                 max: max_length)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks that the cyclomatic complexity of methods is not higher
+      # than the configured maximum. The cyclomatic complexity is the number of
+      # linearly independent paths through a method. The algorithm counts
+      # decision points and adds one.
+      #
+      # An if statement (or unless or ?:) increases the complexity by one. An
+      # else branch does not, since it doesn't add a decision point. The &&
+      # operator (or keyword and) can be converted to a nested if statement,
+      # and ||/or is shorthand for a sequence of ifs, so they also add one.
+      # Loops can be said to have an exit condition, so they add one.
+      class CyclomaticComplexity < Cop
+        include MethodComplexity
+
+        MSG = 'Cyclomatic complexity for %<method>s is too high. ' \
+              '[%<complexity>d/%<max>d]'
+        COUNTED_NODES = %i[if while until for
+                           rescue when and or].freeze
+
+        private
+
+        def complexity_score_for(_node)
+          1
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+# rubocop:disable Metrics/ClassLength
+module RuboCop
+  module Cop
+    module Metrics
+      # This cop checks the length of lines in the source code.
+      # The maximum length is configurable.
+      # The tab size is configured in the `IndentationWidth`
+      # of the `Layout/Tab` cop.
+      # It also ignores a shebang line by default.
+      #
+      # This cop has some autocorrection capabilities.
+      # It can programmatically shorten certain long lines by
+      # inserting line breaks into expressions that can be safely
+      # split across lines. These include arrays, hashes, and
+      # method calls with argument lists.
+      #
+      # If autocorrection is enabled, the following Layout cops
+      # are recommended to further format the broken lines.
+      #
+      #   - AlignArray
+      #   - AlignHash
+      #   - AlignParameters
+      #   - ClosingParenthesisIndentation
+      #   - IndentFirstArgument
+      #   - IndentFirstArrayElement
+      #   - IndentFirstHashElement
+      #   - IndentFirstParameter
+      #   - MultilineArrayLineBreaks
+      #   - MultilineHashBraceLayout
+      #   - MultilineHashKeyLineBreaks
+      #   - MultilineMethodArgumentLineBreaks
+      #
+      # Together, these cops will pretty print hashes, arrays,
+      # method calls, etc. For example, let's say the max columns
+      # is 25:
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good
+      #   {foo: "0000000000",
+      #   bar: "0000000000", baz: "0000000000"}
+      #
+      #   # good (with recommended cops enabled)
+      #   {
+      #     foo: "0000000000",
+      #     bar: "0000000000",
+      #     baz: "0000000000",
+      #   }
+      class LineLength < Cop
+        include CheckLineBreakable
+        include ConfigurableMax
+        include IgnoredPattern
+        include RangeHelp
+
+        MSG = 'Line is too long. [%<length>d/%<max>d]'
+
+        def on_potential_breakable_node(node)
+          check_for_breakable_node(node)
+        end
+        alias on_array on_potential_breakable_node
+        alias on_hash on_potential_breakable_node
+        alias on_send on_potential_breakable_node
+
+        def investigate_post_walk(processed_source)
+          processed_source.lines.each_with_index do |line, line_index|
+            check_line(line, line_index)
+          end
+        end
+
+        def autocorrect(range)
+          return if range.nil?
+
+          lambda do |corrector|
+            corrector.insert_before(range, "\n")
+          end
+        end
+
+        private
+
+        def check_for_breakable_node(node)
+          breakable_node = extract_breakable_node(node, max)
+          return if breakable_node.nil?
+
+          line_index = breakable_node.first_line - 1
+          breakable_nodes_by_line_index[line_index] = breakable_node
+        end
+
+        def breakable_nodes_by_line_index
+          @breakable_nodes_by_line_index ||= {}
+        end
+
+        def heredocs
+          @heredocs ||= extract_heredocs(processed_source.ast)
+        end
+
+        def tab_indentation_width
+          config.for_cop('Layout/Tab')['IndentationWidth']
+        end
+
+        def indentation_difference(line)
+          return 0 unless tab_indentation_width
+
+          line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+        end
+
+        def line_length(line)
+          line.length + indentation_difference(line)
+        end
+
+        def highlight_start(line)
+          max - indentation_difference(line)
+        end
+
+        def check_line(line, line_index)
+          return if line_length(line) <= max
+          return if ignored_line?(line, line_index)
+
+          if ignore_cop_directives? && directive_on_source_line?(line_index)
+            return check_directive_line(line, line_index)
+          end
+          return check_uri_line(line, line_index) if allow_uri?
+
+          register_offense(
+            source_range(
+              processed_source.buffer, line_index,
+              highlight_start(line)...line_length(line)
+            ),
+            line,
+            line_index
+          )
+        end
+
+        def ignored_line?(line, line_index)
+          matches_ignored_pattern?(line) ||
+            shebang?(line, line_index) ||
+            heredocs && line_in_permitted_heredoc?(line_index.succ)
+        end
+
+        def shebang?(line, line_index)
+          line_index.zero? && line.start_with?('#!')
+        end
+
+        def register_offense(loc, line, line_index)
+          message = format(MSG, length: line_length(line), max: max)
+
+          breakable_range = breakable_range(line, line_index)
+          add_offense(breakable_range, location: loc, message: message) do
+            self.max = line_length(line)
+          end
+        end
+
+        def breakable_range(line, line_index)
+          return if line_in_heredoc?(line_index + 1)
+
+          semicolon_range = breakable_semicolon_range(line, line_index)
+          return semicolon_range if semicolon_range
+
+          breakable_node = breakable_nodes_by_line_index[line_index]
+          return breakable_node.source_range if breakable_node
+        end
+
+        def breakable_semicolon_range(line, line_index)
+          semicolon_separated_parts = line.split(';')
+          return if semicolon_separated_parts.length <= 1
+
+          column = semicolon_separated_parts.first.length + 1
+          range = source_range(processed_source.buffer, line_index, column, 1)
+          return if processed_source.commented?(range)
+
+          range
+        end
+
+        def excess_range(uri_range, line, line_index)
+          excessive_position = if uri_range && uri_range.begin < max
+                                 uri_range.end
+                               else
+                                 highlight_start(line)
+                               end
+
+          source_range(processed_source.buffer, line_index + 1,
+                       excessive_position...(line_length(line)))
+        end
+
+        def max
+          cop_config['Max']
+        end
+
+        def allow_heredoc?
+          allowed_heredoc
+        end
+
+        def allowed_heredoc
+          cop_config['AllowHeredoc']
+        end
+
+        def extract_heredocs(ast)
+          return [] unless ast
+
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            delimiter = node.location.heredoc_end.source.strip
+            [body.first_line...body.last_line, delimiter]
+          end
+        end
+
+        def line_in_permitted_heredoc?(line_number)
+          return false unless allowed_heredoc
+
+          heredocs.any? do |range, delimiter|
+            range.cover?(line_number) &&
+              (allowed_heredoc == true || allowed_heredoc.include?(delimiter))
+          end
+        end
+
+        def line_in_heredoc?(line_number)
+          heredocs.any? do |range, _delimiter|
+            range.cover?(line_number)
+          end
+        end
+
+        def allow_uri?
+          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(line) ||
+             uri_range.end == line_length(line) - 1)
+        end
+
+        def find_excessive_uri_range(line)
+          last_uri_match = match_uris(line).last
+          return nil unless last_uri_match
+
+          begin_position, end_position =
+            last_uri_match.offset(0).map do |pos|
+              pos + indentation_difference(line)
+            end
+          return nil if begin_position < max && end_position < max
+
+          begin_position...end_position
+        end
+
+        def match_uris(string)
+          matches = []
+          string.scan(uri_regexp) do
+            matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+          end
+          matches
+        end
+
+        def valid_uri?(uri_ish_string)
+          URI.parse(uri_ish_string)
+          true
+        rescue URI::InvalidURIError, NoMethodError
+          false
+        end
+
+        def uri_regexp
+          @uri_regexp ||=
+            URI::DEFAULT_PARSER.make_regexp(cop_config['URISchemes'])
+        end
+
+        def check_directive_line(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,
+              line_index + 1,
+              range
+            ),
+            line,
+            line_index
+          )
+        end
+
+        def directive_on_source_line?(line_index)
+          source_line_number = line_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, 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, line_index),
+            line,
+            line_index
+          )
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength