rubocop 0.74.0 → 0.75.0

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

@@ -120,6 +120,7 @@ module RuboCop
             corrector.remove(begin_range(node, body))
             corrector.remove(end_range(node, body))
             corrector.insert_before(method_call.loc.dot, '&')
+            handle_comments(corrector, method_call)
 
             add_safe_nav_to_all_methods_in_chain(corrector, method_call, body)
           end
@@ -127,6 +128,14 @@ module RuboCop
 
         private
 
+        def handle_comments(corrector, method_call)
+          return if processed_source.comments.empty?
+
+          comments = processed_source.comments.map(&:text).join("\n")
+          corrector.insert_before(method_call.loc.expression,
+                                  comments + "\n")
+        end
+
         def allowed_if_condition?(node)
           node.else? || node.elsif? || node.ternary?
         end

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

@@ -13,10 +13,17 @@ module RuboCop
       #   def @table.columns; super; end
       #
       #   # good
-      #   def no_op; end
       #   def self.resource_class=(klass); end
       #   def @table.columns; end
       #
+      # @example AllowIfMethodIsEmpty: true (default)
+      #   # good
+      #   def no_op; end
+      #
+      # @example AllowIfMethodIsEmpty: false
+      #   # bad
+      #   def no_op; end
+      #
       class SingleLineMethods < Cop
         include Alignment
 

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

@@ -8,6 +8,11 @@ module RuboCop
       # parentheses using `EnforcedStyle`. Omission is only enforced when
       # removing the parentheses won't cause a different behavior.
       #
+      # `AllowSafeAssignment` option 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."
+      #
       # @example EnforcedStyle: require_no_parentheses (default)
       #   # bad
       #   foo = (bar?) ? a : b
@@ -40,6 +45,15 @@ module RuboCop
       #   foo = bar? ? a : b
       #   foo = bar.baz? ? a : b
       #   foo = (bar && baz) ? a : b
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo = (bar = baz) ? a : b
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo = (bar = baz) ? a : b
+      #
       class TernaryParentheses < Cop
         include SafeAssignment
         include ConfigurableEnforcedStyle
@@ -53,11 +67,16 @@ module RuboCop
           ' complex conditions.'
 
         def on_if(node)
+          return if only_closing_parenthesis_is_last_line?(node.condition)
           return unless node.ternary? && !infinite_loop? && offense?(node)
 
           add_offense(node, location: node.source_range)
         end
 
+        def only_closing_parenthesis_is_last_line?(condition)
+          condition.source.split("\n").last == ')'
+        end
+
         def autocorrect(node)
           condition = node.condition
 

data/lib/rubocop/cop/utils/format_string.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Utils
+      # Parses {Kernel#sprintf} format strings.
+      class FormatString
+        DIGIT_DOLLAR  = /(\d+)\$/.freeze
+        FLAG          = /[ #0+-]|#{DIGIT_DOLLAR}/.freeze
+        NUMBER_ARG    = /\*#{DIGIT_DOLLAR}?/.freeze
+        NUMBER        = /\d+|#{NUMBER_ARG}/.freeze
+        WIDTH         = /(?<width>#{NUMBER})/.freeze
+        PRECISION     = /\.(?<precision>#{NUMBER})/.freeze
+        TYPE          = /(?<type>[bBdiouxXeEfgGaAcps])/.freeze
+        NAME          = /<(?<name>\w+)>/.freeze
+        TEMPLATE_NAME = /\{(?<name>\w+)\}/.freeze
+
+        SEQUENCE = /
+            % (?<type>%)
+          | % (?<flags>#{FLAG}*)
+            (?:
+              (?: #{WIDTH}? #{PRECISION}? #{NAME}?
+                | #{WIDTH}? #{NAME} #{PRECISION}?
+                | #{NAME} (?<more_flags>#{FLAG}*) #{WIDTH}? #{PRECISION}?
+              ) #{TYPE}
+              | #{WIDTH}? #{PRECISION}? #{TEMPLATE_NAME}
+            )
+        /x.freeze
+
+        # The syntax of a format sequence is as follows.
+        #
+        # ```
+        # %[flags][width][.precision]type
+        # ```
+        #
+        # A format sequence consists of a percent sign, followed by optional
+        # flags, width, and precision indicators, then terminated with a field
+        # type character.
+        #
+        # For more complex formatting, Ruby supports a reference by name.
+        #
+        # @see https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-format
+        class FormatSequence
+          attr_reader :begin_pos, :end_pos
+          attr_reader :flags, :width, :precision, :name, :type
+
+          def initialize(string, **opts)
+            @source = string
+            @begin_pos = opts[:begin_pos]
+            @end_pos = opts[:end_pos]
+            @flags = opts[:flags]
+            @width = opts[:width]
+            @precision = opts[:precision]
+            @name = opts[:name]
+            @type = opts[:type]
+          end
+
+          def percent?
+            type == '%'
+          end
+
+          def annotated?
+            name && @source.include?('<')
+          end
+
+          def template?
+            name && @source.include?('{')
+          end
+
+          # Number of arguments required for the format sequence
+          def arity
+            @source.scan('*').count + 1
+          end
+
+          def max_digit_dollar_num
+            @source.scan(DIGIT_DOLLAR).map do |(digit_dollar_num)|
+              digit_dollar_num.to_i
+            end.max
+          end
+
+          def style
+            if annotated?
+              :annotated
+            elsif template?
+              :template
+            else
+              :unannotated
+            end
+          end
+        end
+
+        def initialize(string)
+          @source = string
+        end
+
+        def format_sequences
+          @format_sequences ||= parse
+        end
+
+        def named_interpolation?
+          format_sequences.any?(&:name)
+        end
+
+        def max_digit_dollar_num
+          format_sequences.map(&:max_digit_dollar_num).max
+        end
+
+        private
+
+        def parse
+          @source.to_enum(:scan, SEQUENCE).map do
+            match = Regexp.last_match
+            FormatSequence.new(
+              match[0],
+              begin_pos: match.begin(0),
+              end_pos: match.end(0),
+              flags: match[:flags].to_s + match[:more_flags].to_s,
+              width: match[:width],
+              precision: match[:precision],
+              name: match[:name],
+              type: match[:type]
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_force/variable.rb

@@ -37,7 +37,7 @@ module RuboCop
           !@references.empty?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
@@ -50,6 +50,13 @@ module RuboCop
               assignment.reference!(node)
             end
 
+            # Modifier if/unless conditions are special. Assignments made in
+            # them do not put the assigned variable in scope to the left of the
+            # if/unless keyword. A preceding assignment is needed to put the
+            # variable in scope. For this reason we skip to the next assignment
+            # here.
+            next if in_modifier_if?(assignment)
+
             break if !assignment.branch || assignment.branch == reference.branch
 
             unless assignment.branch.may_run_incompletely?
@@ -57,7 +64,13 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+        def in_modifier_if?(assignment)
+          parent = assignment.node.parent
+          parent = parent.parent if parent&.begin_type?
+          parent&.if_type? && parent&.modifier_form?
+        end
 
         def capture_with_block!
           @captured_by_block = true

data/lib/rubocop/core_ext/string.rb

@@ -20,28 +20,4 @@ class String
       empty? || strip.empty?
     end
   end
-
-  unless method_defined? :strip_indent
-    # The method strips the whitespace preceding the base indentation.
-    # Useful for HEREDOCs and other multi-line strings.
-    #
-    # @example
-    #
-    #   code = <<~END
-    #     def test
-    #       some_method
-    #       other_method
-    #     end
-    #   END
-    #
-    #   #=> "def\n  some_method\n  \nother_method\nend"
-    #
-    # @todo Replace call sites with squiggly heredocs when required Ruby
-    #   version is >= 2.3.0
-    def strip_indent
-      leading_space = scan(/^[ \t]*(?=\S)/).min
-      indent = leading_space ? leading_space.size : 0
-      gsub(/^[ \t]{#{indent}}/, '')
-    end
-  end
 end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -8,11 +8,14 @@ module RuboCop
     class EmacsStyleFormatter < BaseFormatter
       def file_finished(file, offenses)
         offenses.each do |o|
-          message = if o.corrected?
-                      "[Corrected] #{o.message}"
-                    else
-                      o.message
-                    end
+          message =
+            if o.corrected_with_todo?
+              "[Todo] #{o.message}"
+            elsif o.corrected?
+              "[Corrected] #{o.message}"
+            else
+              o.message
+            end
 
           output.printf("%s:%d:%d: %s: %s\n",
                         file, o.line, o.real_column, o.severity.code,

data/lib/rubocop/formatter/formatter_set.rb

@@ -22,7 +22,8 @@ module RuboCop
         'worst'       => WorstOffendersFormatter,
         'tap'         => TapFormatter,
         'quiet'       => QuietFormatter,
-        'autogenconf' => AutoGenConfigFormatter
+        'autogenconf' => AutoGenConfigFormatter,
+        'pacman'      => PacmanFormatter
       }.freeze
 
       FORMATTER_APIS = %i[started finished].freeze

data/lib/rubocop/formatter/pacman_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter prints a PACDOT per every file to be analized.
+    # Pacman will "eat" one PACDOT per file when no offense is detected.
+    # Otherwise it will print a Ghost.
+    # This is inspired by the Pacman formatter for RSpec by Carlos Rojas.
+    # https://github.com/go-labs/rspec_pacman_formatter
+    class PacmanFormatter < ClangStyleFormatter
+      include TextUtil
+      attr_accessor :progress_line
+
+      FALLBACK_TERMINAL_WIDTH = 80
+      GHOST = 'ᗣ'
+      PACMAN = Rainbow('ᗧ').yellow.bright
+      PACDOT = Rainbow('•').yellow.bright
+
+      def initialize(output, options = {})
+        super
+        @progress_line = ''
+        @total_files   = 0
+        @repetitions   = 0
+      end
+
+      def started(target_files)
+        super
+        @total_files = target_files.size
+        output.puts "Eating #{pluralize(target_files.size, 'file')}"
+        update_progress_line
+      end
+
+      def file_started(_file, _options)
+        step(PACMAN)
+      end
+
+      def file_finished(file, offenses)
+        count_stats(offenses) unless offenses.empty?
+        next_step(offenses)
+        report_file(file, offenses)
+      end
+
+      def next_step(offenses)
+        return step('.') if offenses.empty?
+
+        ghost_color = COLOR_FOR_SEVERITY[offenses.last.severity.name]
+        step(colorize(GHOST, ghost_color))
+      end
+
+      def cols
+        @cols ||= begin
+          width = `tput cols`.chomp.to_i
+          width.nil? || width.zero? ? FALLBACK_TERMINAL_WIDTH : width
+        end
+      end
+
+      def update_progress_line
+        return pacdots(@total_files) unless @total_files > cols
+        return pacdots(cols) unless (@total_files / cols).eql?(@repetitions)
+
+        pacdots((@total_files - (cols * @repetitions)))
+      end
+
+      def pacdots(number)
+        @progress_line = PACDOT * number
+      end
+
+      def step(character)
+        regex = /#{Regexp.quote(PACMAN)}|#{Regexp.quote(PACDOT)}/
+        @progress_line = @progress_line.sub(regex, character)
+        output.printf("%s\r", @progress_line)
+        return unless @progress_line[-1] =~ /ᗣ|\./
+
+        @repetitions += 1
+        output.puts
+        update_progress_line
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -75,7 +75,15 @@ module RuboCop
       end
 
       def message(offense)
-        message = offense.corrected? ? green('[Corrected] ') : ''
+        message =
+          if offense.corrected_with_todo?
+            green('[Todo] ')
+          elsif offense.corrected?
+            green('[Corrected] ')
+          else
+            ''
+          end
+
         "#{message}#{annotate_message(offense.message)}"
       end
 

data/lib/rubocop/formatter/tap_formatter.rb

@@ -63,7 +63,15 @@ module RuboCop
       end
 
       def message(offense)
-        message = offense.corrected? ? '[Corrected] ' : ''
+        message =
+          if offense.corrected_with_todo?
+            '[Todo] '
+          elsif offense.corrected?
+            '[Corrected] '
+          else
+            ''
+          end
+
         "#{message}#{annotate_message(offense.message)}"
       end
     end

data/lib/rubocop/magic_comment.rb

@@ -42,6 +42,10 @@ module RuboCop
       frozen_string_literal == true
     end
 
+    def valid_literal_value?
+      [true, false].include?(frozen_string_literal)
+    end
+
     # Was a magic comment for the frozen string literal found?
     #
     # @return [Boolean]

data/lib/rubocop/options.rb

@@ -394,7 +394,7 @@ module RuboCop
                                          "properties to generate. Default is #{MAX_EXCL}."],
       disable_uncorrectable:            ['Used with --auto-correct to annotate any',
                                          'offenses that do not support autocorrect',
-                                         'with `rubocop:disable` comments.'],
+                                         'with `rubocop:todo` comments.'],
       force_exclusion:                  ['Force excluding files specified in the',
                                          'configuration `Exclude` even if they are',
                                          'explicitly passed as arguments.'],
@@ -412,6 +412,7 @@ module RuboCop
                                          '  [c]lang',
                                          '  [d]isabled cops via inline comments',
                                          '  [fu]ubar',
+                                         '  [pa]cman',
                                          '  [e]macs',
                                          '  [j]son',
                                          '  [h]tml',