rubocop 0.93.1 → 1.79.2

data/lib/rubocop/magic_comment.rb

@@ -5,8 +5,15 @@ module RuboCop
   #
   # @abstract parent of three different magic comment handlers
   class MagicComment
-    # @see https://git.io/vMC1C IRB's pattern for matching magic comment tokens
-    TOKEN = /[[:alnum:]\-_]+/.freeze
+    # IRB's pattern for matching magic comment tokens.
+    # @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5
+    TOKEN = '(?<token>[[:alnum:]\-_]+)'
+    KEYWORDS = {
+      encoding: '(?:en)?coding',
+      frozen_string_literal: 'frozen[_-]string[_-]literal',
+      shareable_constant_value: 'shareable[_-]constant[_-]value',
+      typed: 'typed'
+    }.freeze
 
     # Detect magic comment format and pass it to the appropriate wrapper.
     #
@@ -15,8 +22,8 @@ module RuboCop
     # @return [RuboCop::MagicComment]
     def self.parse(comment)
       case comment
-      when EmacsComment::FORMAT then EmacsComment.new(comment)
-      when VimComment::FORMAT   then VimComment.new(comment)
+      when EmacsComment::REGEXP then EmacsComment.new(comment)
+      when VimComment::REGEXP   then VimComment.new(comment)
       else
         SimpleComment.new(comment)
       end
@@ -27,7 +34,14 @@ module RuboCop
     end
 
     def any?
-      frozen_string_literal_specified? || encoding_specified?
+      frozen_string_literal_specified? ||
+        encoding_specified? ||
+        shareable_constant_value_specified? ||
+        typed_specified?
+    end
+
+    def valid?
+      @comment.start_with?('#') && any?
     end
 
     # Does the magic comment enable the frozen string literal feature.
@@ -46,6 +60,10 @@ module RuboCop
       [true, false].include?(frozen_string_literal)
     end
 
+    def valid_shareable_constant_value?
+      %w[none literal experimental_everything experimental_copy].include?(shareable_constant_value)
+    end
+
     # Was a magic comment for the frozen string literal found?
     #
     # @return [Boolean]
@@ -53,15 +71,22 @@ module RuboCop
       specified?(frozen_string_literal)
     end
 
+    # Was a shareable_constant_value specified?
+    #
+    # @return [Boolean]
+    def shareable_constant_value_specified?
+      specified?(shareable_constant_value)
+    end
+
     # Expose the `frozen_string_literal` value coerced to a boolean if possible.
     #
-    # @return [Boolean] if value is `true` or `false`
+    # @return [Boolean] if value is `true` or `false` in any case
     # @return [nil] if frozen_string_literal comment isn't found
     # @return [String] if comment is found but isn't true or false
     def frozen_string_literal
       return unless (setting = extract_frozen_string_literal)
 
-      case setting
+      case setting.downcase
       when 'true'  then true
       when 'false' then false
       else
@@ -69,10 +94,28 @@ module RuboCop
       end
     end
 
+    # Expose the `shareable_constant_value` value coerced to a boolean if possible.
+    #
+    # @return [String] for shareable_constant_value config
+    def shareable_constant_value
+      extract_shareable_constant_value
+    end
+
     def encoding_specified?
       specified?(encoding)
     end
 
+    # Was the Sorbet `typed` sigil specified?
+    #
+    # @return [Boolean]
+    def typed_specified?
+      specified?(extract_typed)
+    end
+
+    def typed
+      extract_typed
+    end
+
     private
 
     def specified?(value)
@@ -86,13 +129,25 @@ module RuboCop
     # @return [String] if pattern matched
     # @return [nil] otherwise
     def extract(pattern)
-      @comment[pattern, 1]
+      @comment[pattern, :token]
     end
 
     # Parent to Vim and Emacs magic comment handling.
     #
     # @abstract
     class EditorComment < MagicComment
+      def encoding
+        match(self.class::KEYWORDS[:encoding])
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        remaining = tokens.grep_v(/\A#{self.class::KEYWORDS[type.to_sym]}/)
+        return '' if remaining.empty?
+
+        self.class::FORMAT % remaining.join(self.class::SEPARATOR)
+      end
+
       private
 
       # Find a token starting with the provided keyword and extract its value.
@@ -102,10 +157,10 @@ module RuboCop
       # @return [String] extracted value if it is found
       # @return [nil] otherwise
       def match(keyword)
-        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*(#{TOKEN})\z/
+        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*#{TOKEN}\z/
 
         tokens.each do |token|
-          next unless (value = token[pattern, 1])
+          next unless (value = token[pattern, :token])
 
           return value.downcase
         end
@@ -117,7 +172,7 @@ module RuboCop
       #
       # @return [Array<String>]
       def tokens
-        extract(self.class::FORMAT).split(self.class::SEPARATOR).map(&:strip)
+        extract(self.class::REGEXP).split(self.class::SEPARATOR).map(&:strip)
       end
     end
 
@@ -131,21 +186,29 @@ module RuboCop
     #   comment.encoding # => 'ascii-8bit'
     #
     # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
-    # @see https://git.io/vMCXh Emacs handling in Ruby's parse.y
+    # @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y
     class EmacsComment < EditorComment
-      FORMAT    = /-\*-(.+)-\*-/.freeze
+      REGEXP    = /-\*-(?<token>.+)-\*-/.freeze
+      FORMAT    = '# -*- %s -*-'
       SEPARATOR = ';'
       OPERATOR  = ':'
 
-      def encoding
-        match('(?:en)?coding')
+      def new_frozen_string_literal(value)
+        "# -*- frozen_string_literal: #{value} -*-"
       end
 
       private
 
       def extract_frozen_string_literal
-        match('frozen[_-]string[_-]literal')
+        match(KEYWORDS[:frozen_string_literal])
+      end
+
+      def extract_shareable_constant_value
+        match(KEYWORDS[:shareable_constant_value])
       end
+
+      # Emacs comments cannot specify Sorbet typechecking behavior.
+      def extract_typed; end
     end
 
     # Wrapper for Vim style magic comments.
@@ -157,9 +220,11 @@ module RuboCop
     #
     #   comment.encoding # => 'ascii-8bit'
     class VimComment < EditorComment
-      FORMAT    = /#\s*vim:\s*(.+)/.freeze
+      REGEXP    = /#\s*vim:\s*(?<token>.+)/.freeze
+      FORMAT    = '# vim: %s'
       SEPARATOR = ', '
       OPERATOR  = '='
+      KEYWORDS = MagicComment::KEYWORDS.merge(encoding: 'fileencoding').freeze
 
       # For some reason the fileencoding keyword only works if there
       # is at least one other token included in the string. For example
@@ -171,11 +236,17 @@ module RuboCop
       #      # vim: foo=bar, fileencoding=ascii-8bit
       #
       def encoding
-        match('fileencoding') if tokens.size > 1
+        super if tokens.size > 1
       end
 
       # Vim comments cannot specify frozen string literal behavior.
       def frozen_string_literal; end
+
+      # Vim comments cannot specify shareable constant values behavior.
+      def shareable_constant_value; end
+
+      # Vim comments cannot specify Sorbet typechecking behavior.
+      def extract_typed; end
     end
 
     # Wrapper for regular magic comments not bound to an editor.
@@ -192,9 +263,24 @@ module RuboCop
     #   comment2.frozen_string_literal # => nil
     #   comment2.encoding              # => 'utf-8'
     class SimpleComment < MagicComment
+      FSTRING_LITERAL_COMMENT = 'frozen_string_literal:\s*(true|false)'
+
       # Match `encoding` or `coding`
       def encoding
-        extract(/\A\s*\#.*\b(?:en)?coding: (#{TOKEN})/i)
+        extract(/\A\s*\#\s*(#{FSTRING_LITERAL_COMMENT})?\s*#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
+      end
+
+      # Rewrite the comment without a given token type
+      def without(type)
+        if @comment.match?(/\A#\s*#{self.class::KEYWORDS[type.to_sym]}/io)
+          ''
+        else
+          @comment
+        end
+      end
+
+      def new_frozen_string_literal(value)
+        "# frozen_string_literal: #{value}"
       end
 
       private
@@ -205,9 +291,17 @@ module RuboCop
       # is the only text in the comment.
       #
       # Case-insensitive and dashes/underscores are acceptable.
-      # @see https://git.io/vM7Mg
+      # @see https://github.com/ruby/ruby/blob/78b95b49f8/parse.y#L7134-L7138
       def extract_frozen_string_literal
-        extract(/\A\s*#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/i)
+        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_shareable_constant_value
+        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
+      end
+
+      def extract_typed
+        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*#{TOKEN}\s*\z/io)
       end
     end
   end

data/lib/rubocop/name_similarity.rb

@@ -16,7 +16,7 @@ module RuboCop
       # DidYouMean::SpellChecker is not available in all versions of Ruby, and
       # even on versions where it *is* available (>= 2.3), it is not always
       # required correctly. So we do a feature check first.
-      # See: https://github.com/rubocop-hq/rubocop/issues/7979
+      # See: https://github.com/rubocop/rubocop/issues/7979
       return [] unless defined?(DidYouMean::SpellChecker)
 
       names = names.dup