rubocop 1.38.0 → 1.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ed47ef39bb205db15249a399d0502f730c2656f712293357651cc0ddd328715
-  data.tar.gz: 5e6411a2b459e0ac426e0ef0d8b8508b9b1693fea0c5b8cb5d82ed23f71d39b9
+  metadata.gz: 881807be0f0f6eea20bd13bd8f08fdb158a5b155c8d3a22fd748683a68c1fef1
+  data.tar.gz: 2a8e7d4b02f1ba468e02a4c20f8e3b830ce2a1d8ff0210f86aaeafab597c8c88
 SHA512:
-  metadata.gz: 5cfd13ac3c283e77e300f87ee923be282740f2763e26c73d21d27b5ae176629d15d8d580d9d326349acf5b71c74e6335689c2192050a818577b9f2e0a6a4484f
-  data.tar.gz: 27f36547ccdf6cc1336e1c44c5e164410f65344cba77fda76ad2db463054adaa93c96a406939b3826412280463a1d6a2940708f4080bc3170999bcc81594ba9d
+  metadata.gz: 11ea36bec754b07912e06b5481f964d10a6dbf5bfd56f99d8a8842ca46d56ae03a342a283d843336f977760c28a697ee995aa98268254a55b1218fa57a9fb5c7
+  data.tar.gz: b5096cb4589d9bafdab0b6ab409ea9e7841dc06b274aeb7f7d5a26e703cb216c2a428d695fb2a087637467f1cdd5ac005398c66ee3e7d28d49cb4b203a87667d

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.38', require: false
+gem 'rubocop', '~> 1.39', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -2808,6 +2808,7 @@ Naming/MethodParameterName:
     - by
     - db
     - id
+    - if
     - in
     - io
     - ip
@@ -3448,7 +3449,7 @@ Style/Copyright:
 
 Style/DateTime:
   Description: 'Use Time over DateTime.'
-  StyleGuide: '#date--time'
+  StyleGuide: '#date-time'
   Enabled: false
   VersionAdded: '0.51'
   VersionChanged: '0.92'
@@ -3819,8 +3820,9 @@ Style/HashExcept:
                  Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
                  that can be replaced with `Hash#except` method.
   Enabled: pending
+  Safe: false
   VersionAdded: '1.7'
-  VersionChanged: '1.31'
+  VersionChanged: '1.39'
 
 Style/HashLikeCase:
   Description: >-

data/lib/rubocop/cop/layout/line_continuation_leading_space.rb

@@ -42,6 +42,14 @@ module RuboCop
       #   ' long'
       class LineContinuationLeadingSpace < Base
         include RangeHelp
+        extend AutoCorrector
+
+        LINE_1_ENDING = /['"]\s*\\\n/.freeze
+        LINE_2_BEGINNING = /\A\s*['"]/.freeze
+        LEADING_STYLE_OFFENSE = /(?<trailing_spaces>\s+)(?<ending>#{LINE_1_ENDING})/.freeze
+        TRAILING_STYLE_OFFENSE = /(?<beginning>#{LINE_2_BEGINNING})(?<leading_spaces>\s+)/.freeze
+        private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
+                         :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
         def on_dstr(node)
           end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
@@ -52,9 +60,9 @@ module RuboCop
             next unless continuation?(raw_line_one)
 
             if enforced_style_leading?
-              investigate_leading_style(raw_line_one, end_of_first_line)
+              investigate_leading_style(raw_line_one, raw_line_two, end_of_first_line)
             else
-              investigate_trailing_style(raw_line_two, end_of_first_line)
+              investigate_trailing_style(raw_line_one, raw_line_two, end_of_first_line)
             end
           end
         end
@@ -65,24 +73,37 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
-        def investigate_leading_style(first_line, end_of_first_line)
-          matches = first_line.match(/(?<trailing_spaces>\s+)(?<ending>['"]\s*\\\n)/)
+        def investigate_leading_style(first_line, second_line, end_of_first_line)
+          matches = first_line.match(LEADING_STYLE_OFFENSE)
           return if matches.nil?
 
-          add_offense(leading_offense_range(end_of_first_line, matches))
+          offense_range = leading_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line + second_line[LINE_2_BEGINNING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:trailing_spaces])
+          end
         end
 
-        def investigate_trailing_style(second_line, end_of_first_line)
-          matches = second_line.match(/\A(?<beginning>\s*['"])(?<leading_spaces>\s+)/)
+        def investigate_trailing_style(first_line, second_line, end_of_first_line)
+          matches = second_line.match(TRAILING_STYLE_OFFENSE)
           return if matches.nil?
 
-          add_offense(trailing_offense_range(end_of_first_line, matches))
+          offense_range = trailing_offense_range(end_of_first_line, matches)
+          add_offense(offense_range) do |corrector|
+            insert_pos = end_of_first_line - first_line[LINE_1_ENDING].length
+            autocorrect(corrector, offense_range, insert_pos, matches[:leading_spaces])
+          end
         end
 
         def continuation?(line)
           line.end_with?("\\\n")
         end
 
+        def autocorrect(corrector, offense_range, insert_pos, spaces)
+          corrector.remove(offense_range)
+          corrector.replace(range_between(insert_pos, insert_pos), spaces)
+        end
+
         def leading_offense_range(end_of_first_line, matches)
           end_pos = end_of_first_line - matches[:ending].length
           begin_pos = end_pos - matches[:trailing_spaces].length

data/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb

@@ -6,6 +6,9 @@ module RuboCop
       # Checks for unnecessary additional spaces inside array percent literals
       # (i.e. %i/%w).
       #
+      # Note that blank percent literals (e.g. `%i( )`) are checked by
+      # `Layout/SpaceInsidePercentLiteralDelimiters`.
+      #
       # @example
       #
       #   # bad

data/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb

@@ -8,14 +8,31 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #   %i( foo bar baz )
+      #
       #   # good
       #   %i(foo bar baz)
       #
       #   # bad
       #   %w( foo bar baz )
       #
+      #   # good
+      #   %w(foo bar baz)
+      #
       #   # bad
       #   %x(  ls -l )
+      #
+      #   # good
+      #   %x(ls -l)
+      #
+      #   # bad
+      #   %w( )
+      #   %w(
+      #   )
+      #
+      #   # good
+      #   %w()
       class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
@@ -34,11 +51,21 @@ module RuboCop
         end
 
         def on_percent_literal(node)
+          add_offenses_for_blank_spaces(node)
           add_offenses_for_unnecessary_spaces(node)
         end
 
         private
 
+        def add_offenses_for_blank_spaces(node)
+          range = body_range(node)
+          return if range.source.empty? || !range.source.strip.empty?
+
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
@@ -54,6 +81,13 @@ module RuboCop
             each_match_range(contents_range(node), regex, &blk)
           end
         end
+
+        def body_range(node)
+          node.location.expression.with(
+            begin_pos: node.location.begin.end_pos,
+            end_pos: node.location.end.begin_pos
+          )
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -51,8 +51,8 @@ module RuboCop
       #   alias bar foo
       class DuplicateMethods < Base
         MSG = 'Method `%<method>s` is defined at both %<defined>s and %<current>s.'
-
         RESTRICT_ON_SEND = %i[alias_method attr_reader attr_writer attr_accessor attr].freeze
+        DEF_TYPES = %i[def defs].freeze
 
         def initialize(config = nil, options = nil)
           super
@@ -127,8 +127,8 @@ module RuboCop
           found_method(node, "#{enclosing}.#{name}")
         end
 
-        def message_for_dup(node, method_name)
-          format(MSG, method: method_name, defined: source_location(@definitions[method_name]),
+        def message_for_dup(node, method_name, key)
+          format(MSG, method: method_name, defined: source_location(@definitions[key]),
                       current: source_location(node))
         end
 
@@ -156,18 +156,27 @@ module RuboCop
         end
 
         def found_method(node, method_name)
-          if @definitions.key?(method_name)
-            loc = case node.type
-                  when :def, :defs
+          key = method_key(node, method_name)
+
+          if @definitions.key?(key)
+            loc = if DEF_TYPES.include?(node.type)
                     node.loc.keyword.join(node.loc.name)
                   else
                     node.loc.expression
                   end
-            message = message_for_dup(node, method_name)
+            message = message_for_dup(node, method_name, key)
 
             add_offense(loc, message: message)
           else
-            @definitions[method_name] = node
+            @definitions[key] = node
+          end
+        end
+
+        def method_key(node, method_name)
+          if (ancestor_def = node.each_ancestor(*DEF_TYPES).first)
+            "#{ancestor_def.method_name}.#{method_name}"
+          else
+            method_name
           end
         end
 

data/lib/rubocop/cop/lint/suppressed_exception.rb

@@ -116,7 +116,7 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block).first
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
           return unless ancestor
 
           end_line = ancestor.loc.end.line

data/lib/rubocop/cop/metrics/abc_size.rb

@@ -20,7 +20,7 @@ module RuboCop
       #
       # @example CountRepeatedAttributes: false (default is true)
       #
-      #    # `model` and `current_user`, refenced 3 times each,
+      #    # `model` and `current_user`, referenced 3 times each,
       #    # are each counted as only 1 branch each if
       #    # `CountRepeatedAttributes` is set to 'false'
       #

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

@@ -126,6 +126,29 @@ module RuboCop
         pos += size * step while condition && src[pos + offset, size] == needle
         pos.negative? ? 0 : pos
       end
+
+      def range_with_comments_and_lines(node)
+        range_by_whole_lines(range_with_comments(node), include_final_newline: true)
+      end
+
+      def range_with_comments(node)
+        ranges = [
+          node,
+          *@processed_source.ast_with_comments[node]
+        ].map do |element|
+          element.location.expression
+        end
+        ranges.reduce do |result, range|
+          add_range(result, range)
+        end
+      end
+
+      def add_range(range1, range2)
+        range1.with(
+          begin_pos: [range1.begin_pos, range2.begin_pos].min,
+          end_pos: [range1.end_pos, range2.end_pos].max
+        )
+      end
     end
   end
 end

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

@@ -1,18 +1,43 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module RuboCop
   module Cop
     # Help methods for determining node visibility.
     module VisibilityHelp
       extend NodePattern::Macros
 
-      VISIBILITY_SCOPES = %i[private protected public].freeze
+      VISIBILITY_SCOPES = ::Set[:private, :protected, :public].freeze
 
       private
 
       def node_visibility(node)
-        scope = find_visibility_start(node)
-        scope&.method_name || :public
+        node_visibility_from_visibility_inline(node) ||
+          node_visibility_from_visibility_block(node) ||
+          :public
+      end
+
+      def node_visibility_from_visibility_inline(node)
+        return unless node.def_type?
+
+        node_visibility_from_visibility_inline_on_def(node) ||
+          node_visibility_from_visibility_inline_on_method_name(node)
+      end
+
+      def node_visibility_from_visibility_inline_on_def(node)
+        parent = node.parent
+        parent.method_name if visibility_inline_on_def?(parent)
+      end
+
+      def node_visibility_from_visibility_inline_on_method_name(node)
+        node.right_siblings.reverse.find do |sibling|
+          visibility_inline_on_method_name?(sibling, method_name: node.method_name)
+        end&.method_name
+      end
+
+      def node_visibility_from_visibility_block(node)
+        find_visibility_start(node)&.method_name
       end
 
       def find_visibility_start(node)
@@ -21,7 +46,7 @@ module RuboCop
 
       # Navigate to find the last protected method
       def find_visibility_end(node)
-        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        possible_visibilities = VISIBILITY_SCOPES - ::Set[node_visibility(node)]
         right = node.right_siblings
         right.find do |child_node|
           possible_visibilities.include?(node_visibility(child_node))
@@ -30,7 +55,17 @@ module RuboCop
 
       # @!method visibility_block?(node)
       def_node_matcher :visibility_block?, <<~PATTERN
-        (send nil? { :private :protected :public })
+        (send nil? VISIBILITY_SCOPES)
+      PATTERN
+
+      # @!method visibility_inline_on_def?(node)
+      def_node_matcher :visibility_inline_on_def?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES def)
+      PATTERN
+
+      # @!method visibility_inline_on_method_name?(node, method_name:)
+      def_node_matcher :visibility_inline_on_method_name?, <<~PATTERN
+        (send nil? VISIBILITY_SCOPES (sym %method_name))
       PATTERN
     end
   end

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

@@ -202,31 +202,7 @@ module RuboCop
         end
 
         def remove_node(corrector, node)
-          corrector.remove(
-            range_by_whole_lines(
-              range_with_comments(node),
-              include_final_newline: true
-            )
-          )
-        end
-
-        def range_with_comments(node)
-          ranges = [
-            node,
-            *processed_source.ast_with_comments[node]
-          ].map do |element|
-            element.location.expression
-          end
-          ranges.reduce do |result, range|
-            add_range(result, range)
-          end
-        end
-
-        def add_range(range1, range2)
-          range1.with(
-            begin_pos: [range1.begin_pos, range2.begin_pos].min,
-            end_pos: [range1.end_pos, range2.end_pos].max
-          )
+          corrector.remove(range_with_comments_and_lines(node))
         end
       end
     end

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

@@ -97,12 +97,14 @@ module RuboCop
           if node.children.first.method?(:name)
             return class_node.receiver.source if class_node.receiver
 
-            value = class_node.source.delete('"').delete("'")
-            value.prepend('::') if class_node.each_ancestor(:class, :module).any?
-            value
-          else
-            class_node.source
+            if class_node.str_type?
+              value = class_node.source.delete('"').delete("'")
+              value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+              return value
+            end
           end
+
+          class_node.source
         end
 
         def offense_range(receiver_node, node)

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.end.end_pos)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
         end
       end
     end

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

@@ -34,6 +34,7 @@ module RuboCop
         extend AutoCorrector
 
         def on_hash(node)
+          return if node.children.first&.kwsplat_type?
           return unless (array = containing_array(node))
           return unless last_array_item?(array, node) && explicit_array?(array)
 

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

@@ -38,28 +38,50 @@ module RuboCop
           ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
         PATTERN
 
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (send $(send _ ${:keys :values}) :each (block_pass (sym _)))
+        PATTERN
+
         def on_block(node)
-          register_kv_offense(node)
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method)
+          end
         end
 
         alias on_numblock on_block
 
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
+        end
+
         private
 
-        def register_kv_offense(node)
-          kv_each(node) do |target, method|
-            parent_receiver = target.receiver.receiver
-            return unless parent_receiver
-            return if allowed_receiver?(parent_receiver)
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          add_offense(kv_range(target), message: format_message(method)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
 
-            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
 
-            add_offense(kv_range(target), message: msg) do |corrector|
-              correct_key_value_each(target, corrector)
-            end
+          range = target.loc.selector.with(end_pos: node.parent.loc.selector.end_pos)
+          add_offense(range, message: format_message(method)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
           end
         end
 
+        def format_message(method_name)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: "#{method_name}.each")
+        end
+
         def check_argument(variable)
           return unless variable.block_argument?
 

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

@@ -13,6 +13,10 @@ module RuboCop
       # when used `==`.
       # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
       #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
       # @example
       #
       #   # bad

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

@@ -25,6 +25,9 @@ module RuboCop
       class ObjectThen < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.6
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 

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

@@ -31,9 +31,22 @@ module RuboCop
           return if rhs.nil? || rhs.children.first
 
           add_offense(dot) do |corrector|
+            wrap_in_parentheses_if_chained(corrector, node)
             corrector.replace(dot, ' ')
           end
         end
+
+        private
+
+        def wrap_in_parentheses_if_chained(corrector, node)
+          return unless node.parent&.call_type?
+
+          operator = node.loc.selector
+
+          ParenthesesCorrector.correct(corrector, node)
+          corrector.insert_after(operator, ' ')
+          corrector.wrap(node, '(', ')')
+        end
       end
     end
   end

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

@@ -93,7 +93,7 @@ module RuboCop
                        end
 
           # The conversion process doubles escaped slashes, so they have to be reverted
-          correction.gsub('\\\\', '\\')
+          correction.gsub('\\\\', '\\').gsub('\"', '"')
         end
 
         def style

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

@@ -7,7 +7,7 @@ module RuboCop
       #
       # @safety
       #   This cop is unsafe, as it can produce false positives if the receiver
-      #   is not an `Enumerable`.
+      #   is not an `Enumerator`.
       #
       # @example
       #
@@ -61,19 +61,24 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def redundant_each_method(node)
-          if node.method?(:each) && !node.parent.block_type?
+          return if node.last_argument&.block_pass_type?
+
+          if node.method?(:each) && !node.parent&.block_type?
             ancestor_node = node.each_ancestor(:send).detect do |ancestor|
-              RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each)
+              ancestor.receiver == node &&
+                (RESTRICT_ON_SEND.include?(ancestor.method_name) || ancestor.method?(:reverse_each))
             end
+
+            return ancestor_node if ancestor_node
           end
 
-          ancestor_node || node.each_descendant(:send).detect do |descendant|
-            next if descendant.parent.block_type?
+          return unless (prev_method = node.children.first)
+          return if !prev_method.send_type? ||
+                    prev_method.parent.block_type? || prev_method.last_argument&.block_pass_type?
 
-            detected = descendant.method_name.to_s.start_with?('each_') unless node.method?(:each)
+          detected = prev_method.method_name.to_s.start_with?('each_') unless node.method?(:each)
 
-            detected || descendant.method?(:reverse_each)
-          end
+          prev_method if detected || prev_method.method?(:reverse_each)
         end
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 

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

@@ -44,7 +44,7 @@ module RuboCop
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
-            next if allowed_escape?(node, char, within_character_class)
+            next if allowed_escape?(node, char, index, within_character_class)
 
             location = escape_range_at_index(node, index)
 
@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        def allowed_escape?(node, char, within_character_class)
+        def allowed_escape?(node, char, index, within_character_class)
           # Strictly speaking a few single-letter metachars are currently
           # unnecessary to "escape", e.g. i, E, F, but enumerating them is
           # rather difficult, and their behavior could change over time with
@@ -65,12 +65,21 @@ module RuboCop
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
 
           if within_character_class
-            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
+              !char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           else
             ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
           end
         end
 
+        def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
+          # The hyphen character is allowed to be escaped within a character class
+          # but it's not necessry to escape hyphen if it's the first or last character
+          # within the character class. This method checks if that's the case.
+          # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
+          node.source[index] == '[' || node.source[index + 3] == ']'
+        end
+
         def delimiter?(node, char)
           delimiters = [node.loc.begin.source[-1], node.loc.end.source[0]]
 

data/lib/rubocop/cop/util.rb

@@ -122,7 +122,7 @@ module RuboCop
           string.inspect
         else
           # In a single-quoted strings, double quotes don't need to be escaped
-          "'#{string.gsub('\"', '"').gsub('\\') { '\\\\' }}'"
+          "'#{string.gsub('\\') { '\\\\' }.gsub('\"', '"')}'"
         end
       end
 

data/lib/rubocop/cops_documentation_generator.rb

@@ -183,11 +183,10 @@ class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
   # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
 
   def to_table(header, content)
-    # Specify `[separator=¦]` to prevent the regexp `|` is not used as a table separator.
-    # See: https://docs.asciidoctor.org/asciidoc/latest/tables/data-format/#escape-the-cell-separator
-    table = ['[separator=¦]', '|===', "| #{header.join(' | ')}\n\n"].join("\n")
+    table = ['|===', "| #{header.join(' | ')}\n\n"].join("\n")
     marked_contents = content.map do |plain_content|
-      plain_content.map { |c| "¦ #{c}" }.join("\n")
+      # Escape `|` with backslash to prevent the regexp `|` is not used as a table separator.
+      plain_content.map { |c| "| #{c.gsub(/\|/, '\|')}" }.join("\n")
     end
     table << marked_contents.join("\n\n")
     table << "\n|===\n"

data/lib/rubocop/server/core.rb

@@ -17,6 +17,8 @@ module RuboCop
     # The core of server process. It starts TCP server and perform socket communication.
     # @api private
     class Core
+      JSON_FORMATS = %w[json j].freeze
+
       def self.token
         @token ||= SecureRandom.hex(4)
       end
@@ -57,6 +59,10 @@ module RuboCop
       def start_server(host, port)
         @server = TCPServer.open(host, port)
 
+        # JSON format does not expected output message when IDE integration with server mode.
+        # See: https://github.com/rubocop/rubocop/issues/11164
+        return if use_json_format?
+
         output_stream = ARGV.include?('--stderr') ? $stderr : $stdout
         output_stream.puts "RuboCop server starting on #{@server.addr[3]}:#{@server.addr[1]}."
       end
@@ -76,6 +82,15 @@ module RuboCop
       ensure
         socket.close
       end
+
+      def use_json_format?
+        return true if ARGV.include?('--format=json') || ARGV.include?('--format=j')
+        return false unless (index = ARGV.index('--format'))
+
+        format = ARGV[index + 1]
+
+        JSON_FORMATS.include?(format)
+      end
     end
   end
 end

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.38.0'
+    STRING = '1.39.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.38.0
+  version: 1.39.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-01 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -985,7 +985,7 @@ metadata:
   homepage_uri: https://rubocop.org/
   changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.38/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.39/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
 post_install_message: