rubocop 0.87.1

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def investigate(processed_source)
+        @modifier_locations = processed_source
+                              .tokens
+                              .select(&:rescue_modifier?)
+                              .map(&:pos)
+      end
+
+      private
+
+      def rescue_modifier?(node)
+        node&.resbody_type? &&
+          @modifier_locations.include?(node.loc.keyword)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for safe assignment. By safe assignment we mean
+    # putting parentheses around an assignment to indicate "I know I'm using an
+    # assignment as a condition. It's not a mistake."
+    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? #setter_method?})'
+
+      def safe_assignment_allowed?
+        cop_config['AllowSafeAssignment']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for missing space after
+    # punctuation.
+    module SpaceAfterPunctuation
+      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, token: kind(token)))
+        end
+      end
+
+      private
+
+      def each_missing_space(tokens)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token1)
+          next unless space_missing?(token1, token2)
+          next unless space_required_before?(token2)
+
+          yield token1
+        end
+      end
+
+      def space_missing?(token1, token2)
+        token1.line == token2.line &&
+          token2.column == token1.column + offset
+      end
+
+      def space_required_before?(token)
+        !(allowed_type?(token) ||
+          (token.right_curly_brace? && space_forbidden_before_rcurly?))
+      end
+
+      def allowed_type?(token)
+        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
+      end
+
+      def space_forbidden_before_rcurly?
+        style = space_style_before_rcurly
+        style == 'no_space'
+      end
+
+      # The normal offset, i.e., the distance from the punctuation
+      # token where a space should be, is 1.
+      def offset
+        1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking for space before
+    # punctuation.
+    module SpaceBeforePunctuation
+      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, token: kind(token)))
+        end
+      end
+
+      private
+
+      def each_missing_space(tokens)
+        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(token1.end_pos,
+                                                 token2.begin_pos)
+
+          yield token2, pos_before_punctuation
+        end
+      end
+
+      def space_missing?(token1, token2)
+        token1.line == token2.line && token2.begin_pos > token1.end_pos
+      end
+
+      def space_required_after?(token)
+        token.left_curly_brace? && space_required_after_lcurly?
+      end
+
+      def space_required_after_lcurly?
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
+        style = cfg['EnforcedStyle'] || 'space'
+        style == 'space'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+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) ||
+                        non_eligible_condition?(node.condition)
+
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        node.nonempty_line_count > 3 ||
+          !node.modifier_form? &&
+            processed_source.commented?(node.loc.end)
+      end
+
+      def non_eligible_body?(body)
+        body.nil? ||
+          body.empty_source? ||
+          body.begin_type? ||
+          processed_source.commented?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
+
+      def modifier_fits_on_single_line?(node)
+        return true unless max_line_length
+
+        length_in_modifier_form(node, node.condition) <= max_line_length
+      end
+
+      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
+        return unless config.for_cop('Layout/LineLength')['Enabled']
+
+        config.for_cop('Layout/LineLength')['Max']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Classes that include this module just implement functions to determine
+    # what is an offense and how to do auto-correction. They get help with
+    # adding offenses for the faulty string nodes, and with filtering out
+    # nodes.
+    module StringHelp
+      def on_str(node)
+        # Constants like __FILE__ are handled as strings,
+        # but don't respond to begin.
+        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return if part_of_ignored_node?(node)
+
+        if offense?(node)
+          add_offense(node) { opposite_style_detected }
+        else
+          correct_style_detected
+        end
+      end
+
+      def on_regexp(node)
+        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?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking single/double quotes.
+    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
+          !/" | \\[^'] | \#(@|\{)/x.match?(src)
+        end
+      end
+    end
+  end
+end