rubocop 0.51.0 → 0.87.0

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

@@ -5,6 +5,8 @@ module RuboCop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
     module PrecedingFollowingAlignment
+      private
+
       def allow_for_alignment?
         cop_config['AllowForAlignment']
       end
@@ -17,6 +19,18 @@ module RuboCop
         aligned_with_adjacent_line?(range, method(:aligned_operator?))
       end
 
+      def aligned_with_preceding_assignment(token)
+        preceding_line_range = token.line.downto(1)
+
+        aligned_with_assignment(token, preceding_line_range)
+      end
+
+      def aligned_with_subsequent_assignment(token)
+        subsequent_line_range = token.line.upto(processed_source.lines.length)
+
+        aligned_with_assignment(token, subsequent_line_range)
+      end
+
       def aligned_with_adjacent_line?(range, predicate)
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
@@ -43,20 +57,23 @@ module RuboCop
 
       def aligned_with_line?(line_nos, range, indent = nil)
         line_nos.each do |lineno|
-          next if comment_lines.include?(lineno + 1)
+          next if aligned_comment_lines.include?(lineno + 1)
+
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
           next if indent && indent != index
+
           return yield(range, line)
         end
         false
       end
 
-      def comment_lines
-        @comment_lines ||= processed_source.comments.map(&:loc).select do |r|
-          begins_its_line?(r.expression)
-        end.map(&:line)
+      def aligned_comment_lines
+        @aligned_comment_lines ||=
+          processed_source.comments.map(&:loc).select do |r|
+            begins_its_line?(r.expression)
+          end.map(&:line)
       end
 
       def aligned_token?(range, line)
@@ -70,7 +87,7 @@ module RuboCop
       end
 
       def aligned_words?(range, line)
-        line[range.column - 1, 2] =~ /\s\S/
+        /\s\S/.match?(line[range.column - 1, 2])
       end
 
       def aligned_char?(range, line)
@@ -84,6 +101,81 @@ module RuboCop
       def aligned_identical?(range, line)
         range.source == line[range.column, range.size]
       end
+
+      def aligned_with_assignment(token, line_range)
+        token_line_indent    = processed_source
+                               .line_indentation(token.line)
+        assignment_lines     = relevant_assignment_lines(line_range)
+        relevant_line_number = assignment_lines[1]
+
+        return :none unless relevant_line_number
+
+        relevant_indent = processed_source
+                          .line_indentation(relevant_line_number)
+
+        return :none if relevant_indent < token_line_indent
+
+        assignment_line = processed_source.lines[relevant_line_number - 1]
+
+        return :none unless assignment_line
+
+        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
+      end
+
+      def assignment_lines
+        @assignment_lines ||= assignment_tokens.map(&:line)
+      end
+
+      def assignment_tokens
+        @assignment_tokens ||= begin
+          tokens = processed_source.tokens.select(&:equal_sign?)
+
+          # we don't want to operate on equals signs which are part of an
+          #   optarg in a method definition
+          # e.g.: def method(optarg = default_val); end
+          tokens = remove_optarg_equals(tokens, processed_source)
+
+          # Only attempt to align the first = on each line
+          Set.new(tokens.uniq(&:line))
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+      def relevant_assignment_lines(line_range)
+        result                        = []
+        original_line_indent          = processed_source
+                                        .line_indentation(line_range.first)
+        relevant_line_indent_at_level = true
+
+        line_range.each do |line_number|
+          current_line_indent = processed_source.line_indentation(line_number)
+          blank_line          = processed_source.lines[line_number - 1].blank?
+
+          if (current_line_indent < original_line_indent && !blank_line) ||
+             (relevant_line_indent_at_level && blank_line)
+            break
+          end
+
+          result << line_number if assignment_lines.include?(line_number) &&
+                                   current_line_indent == original_line_indent
+
+          unless blank_line
+            relevant_line_indent_at_level = \
+              current_line_indent == original_line_indent
+          end
+        end
+
+        result
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
+
+      def remove_optarg_equals(asgn_tokens, processed_source)
+        optargs    = processed_source.ast.each_node(:optarg)
+        optarg_eql = optargs.map { |o| o.loc.operator.begin_pos }.to_set
+        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
+      end
     end
   end
 end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent literal delimiters.
+    class PreferredDelimiters
+      attr_reader :type, :config
+
+      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+
+      def initialize(type, config, preferred_delimiters)
+        @type = type
+        @config = config
+        @preferred_delimiters = preferred_delimiters
+      end
+
+      def delimiters
+        preferred_delimiters[type].split(//)
+      end
+
+      private
+
+      def ensure_valid_preferred_delimiters
+        invalid = preferred_delimiters_config.keys -
+                  (PERCENT_LITERAL_TYPES + %w[default])
+        return if invalid.empty?
+
+        raise ArgumentError,
+              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+      end
+
+      def preferred_delimiters
+        @preferred_delimiters ||=
+          begin
+            ensure_valid_preferred_delimiters
+
+            if preferred_delimiters_config.key?('default')
+              Hash[PERCENT_LITERAL_TYPES.map do |type|
+                [type, preferred_delimiters_config[type] ||
+                  preferred_delimiters_config['default']]
+              end]
+            else
+              preferred_delimiters_config
+            end
+          end
+      end
+
+      def preferred_delimiters_config
+        config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return Parser::Source::Ranges
+    module RangeHelp
+      private
+
+      BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
+
+      def source_range(source_buffer, line_number, column, length = 1)
+        if column.is_a?(Range)
+          column_index = column.begin
+          length = column.size
+        else
+          column_index = column
+        end
+
+        line_begin_pos = if line_number.zero?
+                           0
+                         else
+                           source_buffer.line_range(line_number).begin_pos
+                         end
+        begin_pos = line_begin_pos + column_index
+        end_pos = begin_pos + length
+
+        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+      end
+
+      def range_between(start_pos, end_pos)
+        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
+      end
+
+      def range_with_surrounding_comma(range, side = :both)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
+        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_with_surrounding_space(range:, side: :both,
+                                       newlines: true, whitespace: false)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        if go_left
+          begin_pos =
+            final_pos(src, begin_pos, -1, newlines, whitespace)
+        end
+        end_pos = range.end_pos
+        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_by_whole_lines(range, include_final_newline: false)
+        buffer = @processed_source.buffer
+
+        last_line = buffer.source_line(range.last_line)
+        end_offset = last_line.length - range.last_column
+        end_offset += 1 if include_final_newline
+
+        range
+          .adjust(begin_pos: -range.column, end_pos: end_offset)
+          .intersect(buffer.source_range)
+      end
+
+      def column_offset_between(base_range, range)
+        effective_column(base_range) - effective_column(range)
+      end
+
+      ## Helpers for above range methods. Do not use inside Cops.
+
+      # Returns the column attribute of the range, except if the range is on
+      # the first line and there's a byte order mark at the beginning of that
+      # line, in which case 1 is subtracted from the column value. This gives
+      # the column as it appears when viewing the file in an editor.
+      def effective_column(range)
+        if range.line == 1 &&
+           @processed_source.raw_source.codepoints.first == BYTE_ORDER_MARK
+          range.column - 1
+        else
+          range.column
+        end
+      end
+
+      def directions(side)
+        if side == :both
+          [true, true]
+        else
+          [side == :left, side == :right]
+        end
+      end
+
+      def final_pos(src, pos, increment, newlines, whitespace)
+        pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos(src, pos, increment, newlines, /\n/)
+        move_pos(src, pos, increment, whitespace, /\s/)
+      end
+
+      def move_pos(src, pos, step, condition, regexp)
+        offset = step == -1 ? -1 : 0
+        pos += step while condition && regexp.match?(src[pos + offset])
+        pos.negative? ? 0 : pos
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Rational literals.
+    module RationalLiteral
+      extend NodePattern::Macros
+
+      private
+
+      def_node_matcher :rational_literal?, <<~PATTERN
+        (send
+          (int _) :/
+          (rational _))
+      PATTERN
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling Regexp literals.
+    module RegexpLiteralHelp
+      private
+
+      def freespace_mode_regexp?(node)
+        regopt = node.children.find(&:regopt_type?)
+
+        regopt.children.include?(:x)
+      end
+
+      def pattern_source(node)
+        freespace_mode = freespace_mode_regexp?(node)
+
+        node.children.reject(&:regopt_type?).map do |child|
+          source_with_comments_and_interpolations_blanked(child, freespace_mode)
+        end.join
+      end
+
+      def source_with_comments_and_interpolations_blanked(child, freespace_mode)
+        source = child.source
+
+        # We don't want to consider the contents of interpolations or free-space mode comments as
+        # part of the pattern source, but need to preserve their width, to allow offsets to
+        # correctly line up with the original source: spaces have no effect, and preserve width.
+        if child.begin_type?
+          replace_match_with_spaces(source, /.*/) # replace all content
+        elsif freespace_mode
+          replace_match_with_spaces(source, /(?<!\\)#.*/) # replace any comments
+        else
+          source
+        end
+      end
+
+      def replace_match_with_spaces(source, pattern)
+        source.sub(pattern) { ' ' * Regexp.last_match[0].length }
+      end
+    end
+  end
+end

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

@@ -7,13 +7,14 @@ module RuboCop
       def investigate(processed_source)
         @modifier_locations = processed_source
                               .tokens
-                              .select { |t| t.type == :kRESCUE_MOD }
+                              .select(&:rescue_modifier?)
                               .map(&:pos)
       end
 
+      private
+
       def rescue_modifier?(node)
-        node &&
-          node.resbody_type? &&
+        node&.resbody_type? &&
           @modifier_locations.include?(node.loc.keyword)
       end
     end

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

@@ -8,9 +8,12 @@ module RuboCop
     module SafeAssignment
       extend NodePattern::Macros
 
+      private
+
       def_node_matcher :empty_condition?, '(begin)'
+      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
       def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? asgn_method_call?})'
+                       '(begin {equals_asgn? #setter_method?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

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

@@ -5,32 +5,35 @@ module RuboCop
     # Common functionality for cops checking for missing space after
     # punctuation.
     module SpaceAfterPunctuation
-      MSG = 'Space missing after %s.'.freeze
+      MSG = 'Space missing after %<token>s.'
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token|
           add_offense(token, location: token.pos,
-                             message: format(MSG, kind(token)))
+                             message: format(MSG, token: kind(token)))
         end
       end
 
+      private
+
       def each_missing_space(tokens)
-        tokens.each_cons(2) do |t1, t2|
-          next unless kind(t1)
-          next unless space_missing?(t1, t2)
-          next unless space_required_before?(t2)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token1)
+          next unless space_missing?(token1, token2)
+          next unless space_required_before?(token2)
 
-          yield t1
+          yield token1
         end
       end
 
-      def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+      def space_missing?(token1, token2)
+        token1.line == token2.line &&
+          token2.column == token1.column + offset
       end
 
       def space_required_before?(token)
         !(allowed_type?(token) ||
-          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+          (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)
@@ -47,10 +50,6 @@ module RuboCop
       def offset
         1
       end
-
-      def autocorrect(token)
-        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
-      end
     end
   end
 end

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

@@ -5,34 +5,38 @@ module RuboCop
     # Common functionality for cops checking for space before
     # punctuation.
     module SpaceBeforePunctuation
-      MSG = 'Space found before %s.'.freeze
+      include RangeHelp
+
+      MSG = 'Space found before %<token>s.'
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token, pos_before|
           add_offense(pos_before, location: pos_before,
-                                  message: format(MSG, kind(token)))
+                                  message: format(MSG, token: kind(token)))
         end
       end
 
+      private
+
       def each_missing_space(tokens)
-        tokens.each_cons(2) do |t1, t2|
-          next unless kind(t2)
-          next unless space_missing?(t1, t2)
-          next if space_required_after?(t1)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token2)
+          next unless space_missing?(token1, token2)
+          next if space_required_after?(token1)
 
-          pos_before_punctuation = range_between(t1.pos.end_pos,
-                                                 t2.pos.begin_pos)
+          pos_before_punctuation = range_between(token1.end_pos,
+                                                 token2.begin_pos)
 
-          yield t2, pos_before_punctuation
+          yield token2, pos_before_punctuation
         end
       end
 
-      def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+      def space_missing?(token1, token2)
+        token1.line == token2.line && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)
-        token.type == :tLCURLY && space_required_after_lcurly?
+        token.left_curly_brace? && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?
@@ -40,10 +44,6 @@ module RuboCop
         style = cfg['EnforcedStyle'] || 'space'
         style == 'space'
       end
-
-      def autocorrect(pos_before_punctuation)
-        ->(corrector) { corrector.remove(pos_before_punctuation) }
-      end
     end
   end
 end

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

@@ -4,6 +4,10 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
+      include LineLengthHelp
+
+      private
+
       def single_line_as_modifier?(node)
         return false if non_eligible_node?(node) ||
                         non_eligible_body?(node.body) ||
@@ -13,12 +17,16 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        line_count(node) > 3 ||
-          !node.modifier_form? && commented?(node.loc.end)
+        node.nonempty_line_count > 3 ||
+          !node.modifier_form? &&
+            processed_source.commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)
-        empty_body?(body) || body.begin_type? || commented?(body.source_range)
+        body.nil? ||
+          body.empty_source? ||
+          body.begin_type? ||
+          processed_source.commented?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -26,43 +34,22 @@ module RuboCop
       end
 
       def modifier_fits_on_single_line?(node)
-        modifier_length = length_in_modifier_form(node, node.condition,
-                                                  body_length(node.body))
+        return true unless max_line_length
 
-        modifier_length <= max_line_length
+        length_in_modifier_form(node, node.condition) <= max_line_length
       end
 
-      def length_in_modifier_form(node, cond, body_length)
-        indentation = node.loc.keyword.column
-        kw_length = node.loc.keyword.size
-        cond_length = cond.source_range.size
-        space = 1
-        indentation + body_length + space + kw_length + space + cond_length
+      def length_in_modifier_form(node, cond)
+        keyword = node.loc.keyword
+        indentation = keyword.source_line[/^\s*/]
+        line_length("#{indentation}#{node.body.source} #{keyword.source} " \
+                    "#{cond.source}")
       end
 
       def max_line_length
-        cop_config['MaxLineLength'] ||
-          config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def line_count(node)
-        node.source.lines.grep(/\S/).size
-      end
-
-      def empty_body?(body)
-        !body || body_length(body).zero?
-      end
-
-      def body_length(body)
-        body.source_range ? body.source_range.size : 0
-      end
-
-      def commented?(source)
-        comment_lines.include?(source.line)
-      end
+        return unless config.for_cop('Layout/LineLength')['Enabled']
 
-      def comment_lines
-        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
+        config.for_cop('Layout/LineLength')['Max']
       end
     end
   end

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

@@ -24,6 +24,8 @@ module RuboCop
         ignore_node(node)
       end
 
+      private
+
       def inside_interpolation?(node)
         # A :begin node inside a :dstr node is an interpolation.
         node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)

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

@@ -6,26 +6,16 @@ module RuboCop
     module StringLiteralsHelp
       include StringHelp
 
+      private
+
       def wrong_quotes?(node)
         src = node.source
         return false if src.start_with?('%', '?')
+
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\[^'] | \#(@|\{)/x
-        end
-      end
-
-      def autocorrect(node)
-        return if node.dstr_type?
-
-        lambda do |corrector|
-          str = node.str_content
-          if style == :single_quotes
-            corrector.replace(node.source_range, to_string_literal(str))
-          else
-            corrector.replace(node.source_range, str.inspect)
-          end
+          !/" | \\[^'] | \#(@|\{)/x.match?(src)
         end
       end
     end