rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/mixin/frozen_string_literal.rb

@@ -6,31 +6,56 @@ module RuboCop
     module FrozenStringLiteral
       module_function
 
-      FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
-      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
+      FROZEN_STRING_LITERAL = '# frozen_string_literal:'
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'
       FROZEN_STRING_LITERAL_TYPES = %i[str dstr].freeze
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal_specified?
+          MagicComment.parse(line).valid_literal_value?
         end
       end
 
+      private
+
       def frozen_string_literals_enabled?
         ruby_version = processed_source.ruby_version
         return false unless ruby_version
-        return true if ruby_version >= 3.0
-        return false unless ruby_version >= 2.3
 
+        # TODO: Ruby officially abandon making frozen string literals default
+        # for Ruby 3.0.
+        # https://bugs.ruby-lang.org/issues/11473#note-53
+        # Whether frozen string literals will be the default after Ruby 3.0
+        # or not is still unclear as of January 2019.
+        # It may be necessary to add this code in the future.
+        #
+        #   return true if ruby_version >= 3.1
+        #
+        # And the above `ruby_version >= 3.1` is undecided whether it will be
+        # Ruby 3.1, 3.2, 4.0 or others.
+        # See https://bugs.ruby-lang.org/issues/8976#note-41 for details.
         leading_comment_lines.any? do |line|
           MagicComment.parse(line).frozen_string_literal?
         end
       end
 
-      private
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
 
       def leading_comment_lines
-        processed_source[0..2].compact
+        first_non_comment_token = processed_source.tokens.find do |token|
+          !token.comment?
+        end
+
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...first_non_comment_token.line - 1]
+        else
+          processed_source.lines
+        end
       end
     end
   end

data/lib/rubocop/cop/mixin/{hash_alignment.rb → hash_alignment_styles.rb}

@@ -3,24 +3,53 @@
 module RuboCop
   module Cop
     # Common functionality for checking hash alignment.
-    module HashAlignment
+    module HashAlignmentStyles
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment
         def checkable_layout?(_node)
           true
         end
 
-        def deltas_for_first_pair(*)
-          {}
+        def deltas_for_first_pair(first_pair, _node)
+          {
+            separator: separator_delta(first_pair),
+            value: value_delta(first_pair)
+          }
         end
 
         def deltas(first_pair, current_pair)
           if Util.begins_its_line?(current_pair.source_range)
-            { key: first_pair.key_delta(current_pair) }
+            key_delta = first_pair.key_delta(current_pair)
+            separator_delta = separator_delta(current_pair)
+            value_delta = value_delta(current_pair)
+
+            { key: key_delta, separator: separator_delta, value: value_delta }
           else
             {}
           end
         end
+
+        private
+
+        def separator_delta(pair)
+          if pair.hash_rocket?
+            correct_separator_column = pair.key.loc.expression.end.column + 1
+            actual_separator_column = pair.loc.operator.column
+
+            correct_separator_column - actual_separator_column
+          else
+            0
+          end
+        end
+
+        def value_delta(pair)
+          return 0 if pair.kwsplat_type? || pair.value_on_new_line?
+
+          correct_value_column = pair.loc.operator.end.column + 1
+          actual_value_column = pair.value.loc.column
+
+          correct_value_column - actual_value_column
+        end
       end
 
       # Common functionality for checking alignment of hash values.
@@ -54,8 +83,10 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
-        # The table style is the only one where the first key-value pair can
-        # be considered to have bad alignment.
+        def initialize
+          self.max_key_width = 0
+        end
+
         def deltas_for_first_pair(first_pair, node)
           self.max_key_width = node.keys.map { |key| key.source.length }.max
 
@@ -93,7 +124,7 @@ module RuboCop
       class SeparatorAlignment
         include ValueAlignment
 
-        def deltas_for_first_pair(*)
+        def deltas_for_first_pair(*_nodes)
           {}
         end
 

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        add_offense(
+          node,
+          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        )
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = 0
+
+          unless node.parent&.block_type?
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/heredoc.rb

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
 
-# Common functionality for working with heredoc strings.
-module Heredoc
-  OPENING_DELIMITER = /<<[~-]?['"`]?([^'"`]+)['"`]?/
+module RuboCop
+  module Cop
+    # Common functionality for working with heredoc strings.
+    module Heredoc
+      OPENING_DELIMITER = /(<<[~-]?)['"`]?([^'"`]+)['"`]?/.freeze
 
-  def on_str(node)
-    return unless heredoc?(node)
+      def on_str(node)
+        return unless node.heredoc?
 
-    on_heredoc(node)
-  end
-  alias on_dstr on_str
-  alias on_xstr on_str
+        on_heredoc(node)
+      end
+      alias on_dstr on_str
+      alias on_xstr on_str
 
-  def on_heredoc(_node)
-    raise NotImplementedError
-  end
+      def on_heredoc(_node)
+        raise NotImplementedError
+      end
 
-  private
+      private
 
-  def heredoc?(node)
-    node.loc.is_a?(Parser::Source::Map::Heredoc)
-  end
+      def delimiter_string(node)
+        node.source.match(OPENING_DELIMITER).captures[1]
+      end
 
-  def delimiter_string(node)
-    node.source.match(OPENING_DELIMITER).captures.first
+      def heredoc_type(node)
+        node.source.match(OPENING_DELIMITER).captures[0]
+      end
+    end
   end
 end

data/lib/rubocop/cop/mixin/ignored_methods.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain methods when
+    # parsing.
+    module IgnoredMethods
+      private
+
+      def ignored_method?(name)
+        ignored_methods.include?(name.to_s)
+      end
+
+      def ignored_methods
+        cop_config.fetch('IgnoredMethods', [])
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/ignored_pattern.rb

@@ -5,6 +5,8 @@ module RuboCop
     # This module encapsulates the ability to ignore certain lines when
     # parsing.
     module IgnoredPattern
+      private
+
       def ignored_line?(line)
         line = if line.respond_to?(:source_line)
                  line.source_line
@@ -16,7 +18,7 @@ module RuboCop
       end
 
       def matches_ignored_pattern?(line)
-        ignored_patterns.any? { |pattern| Regexp.new(pattern).match(line) }
+        ignored_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
       end
 
       def ignored_patterns

data/lib/rubocop/cop/mixin/integer_node.rb

@@ -4,8 +4,10 @@ module RuboCop
   module Cop
     # Common functionality for checking integer nodes.
     module IntegerNode
+      private
+
       def integer_part(node)
-        node.source.sub(/^[+-]/, '').split('.').first
+        node.source.sub(/^[+-]/, '').split(/[eE.]/, 2).first
       end
     end
   end

data/lib/rubocop/cop/mixin/interpolation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

data/lib/rubocop/cop/mixin/line_length_help.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      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 allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      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_line_length &&
+                      end_position < max_line_length
+
+        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 indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        line.match(/^\t*/)[0].size * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/match_range.rb

@@ -4,6 +4,10 @@ module RuboCop
   module Cop
     # Common functionality for obtaining source ranges from regexp matches
     module MatchRange
+      include RangeHelp
+
+      private
+
       # Return a new `Range` covering the first matching group number for each
       # match of `regex` inside `range`
       def each_match_range(range, regex)

data/lib/rubocop/cop/mixin/method_complexity.rb

@@ -5,25 +5,55 @@ module RuboCop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      include IgnoredMethods
+      extend NodePattern::Macros
 
       def on_def(node)
+        return if ignored_method?(node.method_name)
+
+        check_complexity(node, node.method_name)
+      end
+      alias on_defs on_def
+
+      def on_block(node)
+        define_method?(node) do |name|
+          return if ignored_method?(name)
+
+          check_complexity(node, name)
+        end
+      end
+
+      private
+
+      def_node_matcher :define_method?, <<~PATTERN
+        (block
+         (send nil? :define_method ({sym str} $_))
+         args
+         _)
+      PATTERN
+
+      def check_complexity(node, method_name)
+        # Accepts empty methods always.
+        return unless node.body
+
         max = cop_config['Max']
-        complexity = complexity(node)
+        complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
 
-        msg = format(self.class::MSG, node.method_name, complexity, max)
+        msg = format(self.class::MSG,
+                     method: method_name,
+                     complexity: complexity,
+                     abc_vector: abc_vector,
+                     max: max)
 
-        add_offense(node, location: :keyword, message: msg) do
+        add_offense(node, message: msg) do
           self.max = complexity.ceil
         end
       end
-      alias on_defs on_def
-
-      private
 
-      def complexity(node)
-        node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
+      def complexity(body)
+        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
           score + complexity_score_for(n)
         end
       end

data/lib/rubocop/cop/mixin/method_preference.rb

@@ -18,7 +18,8 @@ module RuboCop
             default = default_cop_config['PreferredMethods']
             merged = cop_config['PreferredMethods']
             overrides = merged.values - default.values
-            merged.reject { |key, _| overrides.include?(key) }.symbolize_keys
+            merged.reject { |key, _| overrides.include?(key) }
+                  .map { |k, v| [k.to_sym, v] }.to_h
           end
       end
 

data/lib/rubocop/cop/mixin/min_body_length.rb

@@ -4,13 +4,15 @@ module RuboCop
   module Cop
     # Common functionality for checking minimum body length.
     module MinBodyLength
+      private
+
       def min_body_length?(node)
         (node.loc.end.line - node.loc.keyword.line) > min_body_length
       end
 
       def min_body_length
         length = cop_config['MinBodyLength'] || 1
-        return length if length.is_a?(Integer) && length > 0
+        return length if length.is_a?(Integer) && length.positive?
 
         raise 'MinBodyLength needs to be a positive integer!'
       end

data/lib/rubocop/cop/mixin/{array_hash_indentation.rb → multiline_element_indentation.rb}

@@ -2,8 +2,11 @@
 
 module RuboCop
   module Cop
-    # Common code for indenting literal arrays and hashes.
-    module ArrayHashIndentation
+    # Common code for indenting the first elements in multiline
+    # array literals, hash literals, and method definitions.
+    module MultilineElementIndentation
+      private
+
       def each_argument_node(node, type)
         left_parenthesis = node.loc.begin