rubocop 0.93.1 → 1.3.1

data/lib/rubocop/cop/style/swap_values.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of shorthand-style swapping of 2 variables.
+      # Its autocorrection is marked as unsafe, because it can erroneously remove
+      # the temporary variable which is used later.
+      #
+      # @example
+      #   # bad
+      #   tmp = x
+      #   x = y
+      #   y = tmp
+      #
+      #   # good
+      #   x, y = y, x
+      #
+      class SwapValues < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Replace this and assignments at lines %<x_line>d '\
+          'and %<y_line>d with `%<replacement>s`.'
+
+        SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze
+
+        def on_asgn(node)
+          return if allowed_assignment?(node)
+
+          tmp_assign = node
+          x_assign, y_assign = *node.right_siblings.take(2)
+          return unless x_assign && y_assign && swapping_values?(tmp_assign, x_assign, y_assign)
+
+          add_offense(node, message: message(x_assign, y_assign)) do |corrector|
+            range = correction_range(tmp_assign, y_assign)
+            corrector.replace(range, replacement(x_assign))
+          end
+        end
+
+        SIMPLE_ASSIGNMENT_TYPES.each { |asgn_type| alias_method :"on_#{asgn_type}", :on_asgn }
+
+        private
+
+        def allowed_assignment?(node)
+          node.parent&.mlhs_type? || node.parent&.shorthand_asgn?
+        end
+
+        def swapping_values?(tmp_assign, x_assign, y_assign)
+          simple_assignment?(tmp_assign) &&
+            simple_assignment?(x_assign) &&
+            simple_assignment?(y_assign) &&
+            lhs(x_assign) == rhs(tmp_assign) &&
+            lhs(y_assign) == rhs(x_assign) &&
+            rhs(y_assign) == lhs(tmp_assign)
+        end
+
+        def simple_assignment?(node)
+          SIMPLE_ASSIGNMENT_TYPES.include?(node.type)
+        end
+
+        def message(x_assign, y_assign)
+          format(
+            MSG,
+            x_line: x_assign.first_line,
+            y_line: y_assign.first_line,
+            replacement: replacement(x_assign)
+          )
+        end
+
+        def replacement(x_assign)
+          x = lhs(x_assign)
+          y = rhs(x_assign)
+          "#{x}, #{y} = #{y}, #{x}"
+        end
+
+        def lhs(node)
+          case node.type
+          when :casgn
+            namespace, name, = *node
+            if namespace
+              "#{namespace.const_name}::#{name}"
+            else
+              name.to_s
+            end
+          else
+            node.children[0].to_s
+          end
+        end
+
+        def rhs(node)
+          case node.type
+          when :casgn
+            node.children[2].source
+          else
+            node.children[1].source
+          end
+        end
+
+        def correction_range(tmp_assign, y_assign)
+          range_by_whole_lines(
+            range_between(tmp_assign.source_range.begin_pos, y_assign.source_range.end_pos)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/trailing_underscore_variable.rb

@@ -36,6 +36,8 @@ module RuboCop
         MSG = 'Do not use trailing `_`s in parallel assignment. ' \
               'Prefer `%<code>s`.'
         UNDERSCORE = '_'
+        DISALLOW = %i[lvasgn splat].freeze
+        private_constant :DISALLOW
 
         def on_masgn(node)
           ranges = unneeded_ranges(node)
@@ -64,7 +66,7 @@ module RuboCop
 
         def find_first_possible_offense(variables)
           variables.reduce(nil) do |offense, variable|
-            break offense unless %i[lvasgn splat].include?(variable.type)
+            break offense unless DISALLOW.include?(variable.type)
 
             var, = *variable
             var, = *var

data/lib/rubocop/cop/style/while_until_modifier.rb

@@ -24,6 +24,15 @@ module RuboCop
       #
       #   # good
       #   x += 1 until x > 10
+      #
+      # @example
+      #   # bad
+      #   x += 100 while x < 500 # a long comment that makes code too long if it were a single line
+      #
+      #   # good
+      #   while x < 500 # a long comment that makes code too long if it were a single line
+      #     x += 100
+      #   end
       class WhileUntilModifier < Base
         include StatementModifier
         extend AutoCorrector

data/lib/rubocop/cop/team.rb

@@ -99,7 +99,12 @@ module RuboCop
       def self.forces_for(cops)
         needed = Hash.new { |h, k| h[k] = [] }
         cops.each do |cop|
-          Array(cop.class.joining_forces).each { |force| needed[force] << cop }
+          forces = cop.class.joining_forces
+          if forces.is_a?(Array)
+            forces.each { |force| needed[force] << cop }
+          elsif forces
+            needed[forces] << cop
+          end
         end
 
         needed.map do |force_class, joining_cops|

data/lib/rubocop/cop/util.rb

@@ -62,7 +62,7 @@ module RuboCop
       end
 
       def begins_its_line?(range)
-        (range.source_line =~ /\S/) == range.column
+        range.source_line.index(/\S/) == range.column
       end
 
       # Returns, for example, a bare `if` node if the given node is an `if`
@@ -123,6 +123,10 @@ module RuboCop
           node1.loc.line == node2.loc.line
       end
 
+      def indent(node)
+        ' ' * node.loc.column
+      end
+
       def to_supported_styles(enforced_style)
         enforced_style
           .sub(/^Enforced/, 'Supported')

data/lib/rubocop/ext/regexp_node.rb

@@ -10,18 +10,26 @@ module RuboCop
       end
       private_constant :ANY
 
-      class << self
-        attr_reader :parsed_cache
-      end
-      @parsed_cache = {}
-
       # @return [Regexp::Expression::Root, nil]
-      def parsed_tree
+      # Note: we extend Regexp nodes to provide `loc` and `expression`
+      # see `ext/regexp_parser`.
+      attr_reader :parsed_tree
+
+      def assign_properties(*)
+        super
+
         str = with_interpolations_blanked
-        Ext::RegexpNode.parsed_cache[str] ||= begin
-          Regexp::Parser.parse(str, options: options)
+        begin
+          @parsed_tree = Regexp::Parser.parse(str, options: options)
         rescue StandardError
-          nil
+          @parsed_tree = nil
+        else
+          origin = loc.begin.end
+          source = @parsed_tree.to_s
+          @parsed_tree.each_expression(true) do |e|
+            e.origin = origin
+            e.source = source
+          end
         end
       end
 

data/lib/rubocop/ext/regexp_parser.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Ext
+    # Extensions for `regexp_parser` gem
+    module RegexpParser
+      # Source map for RegexpParser nodes
+      class Map < ::Parser::Source::Map
+        attr_reader :body, :quantifier, :begin, :end
+
+        def initialize(expression, body:, quantifier: nil, begin_l: nil, end_l: nil)
+          @begin = begin_l
+          @end = end_l
+          @body = body
+          @quantifier = quantifier
+          super(expression)
+        end
+      end
+
+      module Expression
+        # Add `expression` and `loc` to all `regexp_parser` nodes
+        module Base
+          attr_accessor :origin, :source
+
+          def start_index
+            # ts is a byte index; convert it to a character index
+            @start_index ||= source.byteslice(0, ts).length
+          end
+
+          # Shortcut to `loc.expression`
+          def expression
+            @expression ||= begin
+              origin.adjust(begin_pos: start_index, end_pos: start_index + full_length)
+            end
+          end
+
+          # @returns a location map like `parser` does, with:
+          #   - expression: complete expression
+          #   - quantifier: for `+`, `{1,2}`, etc.
+          #   - begin/end: for `[` and `]` (only CharacterSet for now)
+          #
+          # E.g.
+          #     [a-z]{2,}
+          #     ^^^^^^^^^ expression
+          #          ^^^^ quantifier
+          #     ^^^^^     body
+          #     ^         begin
+          #         ^     end
+          #
+          # Please open issue if you need other locations
+          def loc
+            @loc ||= begin
+              Map.new(expression, **build_location)
+            end
+          end
+
+          private
+
+          def build_location
+            return { body: expression } unless (q = quantifier)
+
+            body = expression.adjust(end_pos: -q.text.length)
+            q_loc = expression.with(begin_pos: body.end_pos)
+            { body: body, quantifier: q_loc }
+          end
+        end
+
+        # Provide `CharacterSet` with `begin` and `end` locations.
+        module CharacterSet
+          def build_location
+            h = super
+            body = h[:body]
+            h.merge!(
+              begin_l: body.with(end_pos: body.begin_pos + 1),
+              end_l: body.with(begin_pos: body.end_pos - 1)
+            )
+          end
+        end
+      end
+      ::Regexp::Expression::Base.include Expression::Base
+      ::Regexp::Expression::CharacterSet.include Expression::CharacterSet
+    end
+  end
+end

data/lib/rubocop/formatter/formatter_set.rb

@@ -14,6 +14,7 @@ module RuboCop
         '[e]macs'       => EmacsStyleFormatter,
         '[fi]les'       => FileListFormatter,
         '[fu]ubar'      => FuubarStyleFormatter,
+        '[g]ithub'      => GitHubActionsFormatter,
         '[h]tml'        => HTMLFormatter,
         '[j]son'        => JSONFormatter,
         '[ju]nit'       => JUnitFormatter,
@@ -30,7 +31,7 @@ module RuboCop
 
       FORMATTER_APIS.each do |method_name|
         define_method(method_name) do |*args|
-          each { |f| f.send(method_name, *args) }
+          each { |f| f.public_send(method_name, *args) }
         end
       end
 

data/lib/rubocop/formatter/git_hub_actions_formatter.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data as GitHub Workflow commands resulting
+    # in GitHub check annotations when run within GitHub Actions.
+    class GitHubActionsFormatter < BaseFormatter
+      ESCAPE_MAP = {
+        '%' => '%25',
+        "\n" => '%0A',
+        "\r" => '%0D'
+      }.freeze
+
+      def file_finished(file, offenses)
+        offenses.each { |offense| report_offense(file, offense) }
+      end
+
+      private
+
+      def github_escape(string)
+        string.gsub(Regexp.union(ESCAPE_MAP.keys), ESCAPE_MAP)
+      end
+
+      def minimum_severity_to_fail
+        @minimum_severity_to_fail ||= begin
+          name = options.fetch(:fail_level, :refactor)
+          RuboCop::Cop::Severity.new(name)
+        end
+      end
+
+      def github_severity(offense)
+        offense.severity < minimum_severity_to_fail ? 'warning' : 'error'
+      end
+
+      def report_offense(file, offense)
+        output.printf(
+          "\n::%<severity>s file=%<file>s,line=%<line>d,col=%<column>d::%<message>s\n",
+          severity: github_severity(offense),
+          file: file,
+          line: offense.line,
+          column: offense.real_column,
+          message: github_escape(offense.message)
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/offense_count_formatter.rb

@@ -67,7 +67,7 @@ module RuboCop
       end
 
       def total_offense_count(offense_counts)
-        offense_counts.values.inject(0, :+)
+        offense_counts.values.sum
       end
     end
   end

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -55,7 +55,7 @@ module RuboCop
       end
 
       def total_offense_count(offense_counts)
-        offense_counts.values.inject(0, :+)
+        offense_counts.values.sum
       end
     end
   end

data/lib/rubocop/magic_comment.rb

@@ -194,7 +194,7 @@ module RuboCop
     class SimpleComment < MagicComment
       # Match `encoding` or `coding`
       def encoding
-        extract(/\A\s*\#.*\b(?:en)?coding: (#{TOKEN})/i)
+        extract(/\A\s*\#.*\b(?:en)?coding: (#{TOKEN})/io)
       end
 
       private
@@ -207,7 +207,7 @@ module RuboCop
       # Case-insensitive and dashes/underscores are acceptable.
       # @see https://git.io/vM7Mg
       def extract_frozen_string_literal
-        extract(/\A\s*#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/i)
+        extract(/\A\s*#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/io)
       end
     end
   end

data/lib/rubocop/options.rb

@@ -145,6 +145,7 @@ module RuboCop
         end
       end
 
+      option(opts, '--display-time')
       option(opts, '--display-only-failed')
     end
 
@@ -242,6 +243,9 @@ module RuboCop
   # @api private
   class OptionsValidator
     class << self
+      SYNTAX_DEPARTMENTS = %w[Syntax Lint/Syntax].freeze
+      private_constant :SYNTAX_DEPARTMENTS
+
       # Cop name validation must be done later than option parsing, so it's not
       # called from within Options.
       def validate_cop_list(names)
@@ -253,7 +257,7 @@ module RuboCop
         names.each do |name|
           next if cop_names.include?(name)
           next if departments.include?(name)
-          next if %w[Syntax Lint/Syntax].include?(name)
+          next if SYNTAX_DEPARTMENTS.include?(name)
 
           raise IncorrectCopNameError, format_message_from(name, cop_names)
         end
@@ -466,6 +470,7 @@ module RuboCop
                                          'if no format is specified.'],
       fail_level:                       ['Minimum severity (A/R/C/W/E/F) for exit',
                                          'with error code.'],
+      display_time:                     'Display elapsed time in seconds.',
       display_only_failed:              ['Only output offense messages. Omit passing',
                                          'cops. Only valid for --format junit.'],
       display_only_fail_level_offenses:

data/lib/rubocop/rspec/shared_contexts.rb

@@ -138,3 +138,7 @@ end
 RSpec.shared_context 'ruby 2.7', :ruby27 do
   let(:ruby_version) { 2.7 }
 end
+
+RSpec.shared_context 'ruby 3.0', :ruby30 do
+  let(:ruby_version) { 3.0 }
+end

data/lib/rubocop/target_finder.rb

@@ -94,7 +94,7 @@ module RuboCop
     end
 
     def wanted_dir_patterns(base_dir, exclude_pattern, flags)
-      dirs = Dir.glob(File.join(base_dir, '*/'), flags)
+      dirs = Dir.glob(File.join(base_dir.gsub('/**/', '/\**/'), '*/'), flags)
                 .reject do |dir|
                   dir.end_with?('/./', '/../') || File.fnmatch?(exclude_pattern, dir, flags)
                 end