rubocop 0.42.0 → 0.52.1

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -1,8 +1,7 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'rubocop/formatter/colorizable'
-require 'rubocop/formatter/text_util'
+require_relative 'colorizable'
+require_relative 'text_util'
 
 module RuboCop
   module Formatter
@@ -10,7 +9,8 @@ module RuboCop
     # Offenses are displayed at compact form - just the
     # location of the problem and the associated message.
     class SimpleTextFormatter < BaseFormatter
-      include Colorizable, PathUtil
+      include Colorizable
+      include PathUtil
 
       COLOR_FOR_SEVERITY = {
         refactor:   :yellow,
@@ -64,24 +64,13 @@ module RuboCop
         @total_correction_count += offenses.count(&:corrected?)
       end
 
-      def smart_path(path)
-        # Ideally, we calculate this relative to the project root.
-        base_dir = Dir.pwd
-
-        if path.start_with? base_dir
-          relative_path(path, base_dir)
-        else
-          path
-        end
-      end
-
       def colored_severity_code(offense)
         color = COLOR_FOR_SEVERITY[offense.severity.name]
         colorize(offense.severity.code, color)
       end
 
       def annotate_message(msg)
-        msg.gsub(/`(.*?)`/, yellow('\1'))
+        msg.gsub(/`(.*?)`/m, yellow('\1'))
       end
 
       def message(offense)
@@ -91,7 +80,8 @@ module RuboCop
 
       # A helper class for building the report summary text.
       class Report
-        include Colorizable, TextUtil
+        include Colorizable
+        include TextUtil
 
         def initialize(file_count, offense_count, correction_count, rainbow)
           @file_count = file_count

data/lib/rubocop/formatter/tap_formatter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Formatter
+    # This formatter formats report data using the Test Anything Protocol.
+    # TAP allows for to communicate tests results in a language agnostics way.
+    class TapFormatter < ClangStyleFormatter
+      def started(target_files)
+        super
+        @progress_count = 1
+        output.puts "1..#{target_files.size}"
+      end
+
+      def file_finished(file, offenses)
+        if offenses.empty?
+          output.puts "ok #{@progress_count} - #{smart_path(file)}"
+        else
+          output.puts "not ok #{@progress_count} - #{smart_path(file)}"
+
+          count_stats(offenses)
+          report_file(file, offenses)
+        end
+
+        @progress_count += 1
+      end
+
+      private
+
+      def report_line(location)
+        source_line = location.source_line
+
+        if location.first_line == location.last_line
+          output.puts("# #{source_line}")
+        else
+          output.puts("# #{source_line} #{yellow(ELLIPSES)}")
+        end
+      end
+
+      def report_highlighted_area(highlighted_area)
+        output.puts("# #{' ' * highlighted_area.begin_pos}" \
+                    "#{'^' * highlighted_area.size}")
+      end
+
+      def report_offense(file, offense)
+        output.printf("# %s:%d:%d: %s: %s\n",
+                      cyan(smart_path(file)), offense.line, offense.real_column,
+                      colored_severity_code(offense), message(offense))
+
+        # rubocop:disable Lint/HandleExceptions
+        begin
+          return unless valid_line?(offense)
+
+          report_line(offense.location)
+          report_highlighted_area(offense.highlighted_area)
+        rescue IndexError
+          # range is not on a valid line; perhaps the source file is empty
+        end
+        # rubocop:enable Lint/HandleExceptions
+      end
+
+      def annotate_message(msg)
+        msg.gsub(/`(.*?)`/, '\1')
+      end
+
+      def message(offense)
+        message = offense.corrected? ? '[Corrected] ' : ''
+        "#{message}#{annotate_message(offense.message)}"
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/text_util.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'pathname'
@@ -23,16 +22,17 @@ module RuboCop
       end
 
       def file_finished(file, offenses)
-        unless offenses.empty?
-          path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
-          @offense_counts[path] = offenses.size
-        end
+        return if offenses.empty?
+
+        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        @offense_counts[path] = offenses.size
       end
 
       def finished(_inspected_files)
         report_summary(@offense_counts)
       end
 
+      # rubocop:disable Metrics/AbcSize
       def report_summary(offense_counts)
         per_file_counts = ordered_offense_counts(offense_counts)
         total_count = total_offense_count(offense_counts)
@@ -48,6 +48,7 @@ module RuboCop
 
         output.puts
       end
+      # rubocop:enable Metrics/AbcSize
 
       def ordered_offense_counts(offense_counts)
         Hash[offense_counts.sort_by { |k, v| [-v, k] }]

data/lib/rubocop/magic_comment.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Parse different formats of magic comments.
+  #
+  # @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:]\-_]+/
+
+    # Detect magic comment format and pass it to the appropriate wrapper.
+    #
+    # @param comment [String]
+    #
+    # @return [RuboCop::MagicComment]
+    def self.parse(comment)
+      case comment
+      when EmacsComment::FORMAT then EmacsComment.new(comment)
+      when VimComment::FORMAT   then VimComment.new(comment)
+      else
+        SimpleComment.new(comment)
+      end
+    end
+
+    def initialize(comment)
+      @comment = comment
+    end
+
+    def any?
+      frozen_string_literal_specified? || encoding_specified?
+    end
+
+    # Does the magic comment enable the frozen string literal feature.
+    #
+    # Test whether the frozen string literal value is `true`. Cannot
+    # just return `frozen_string_literal` since an invalid magic comment
+    # like `# frozen_string_literal: yes` is possible and the truthy value
+    # `'yes'` does not actually enable the feature
+    #
+    # @return [Boolean]
+    def frozen_string_literal?
+      frozen_string_literal == true
+    end
+
+    # Was a magic comment for the frozen string literal found?
+    #
+    # @return [Boolean]
+    def frozen_string_literal_specified?
+      specified?(frozen_string_literal)
+    end
+
+    # Expose the `frozen_string_literal` value coerced to a boolean if possible.
+    #
+    # @return [Boolean] if value is `true` or `false`
+    # @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
+      when 'true'  then true
+      when 'false' then false
+      else
+        setting
+      end
+    end
+
+    def encoding_specified?
+      specified?(encoding)
+    end
+
+    private
+
+    def specified?(value)
+      !value.nil?
+    end
+
+    # Match the entire comment string with a pattern and take the first capture.
+    #
+    # @param pattern [Regexp]
+    #
+    # @return [String] if pattern matched
+    # @return [nil] otherwise
+    def extract(pattern)
+      @comment[pattern, 1]
+    end
+
+    # Parent to Vim and Emacs magic comment handling.
+    #
+    # @abstract
+    class EditorComment < MagicComment
+      private
+
+      # Find a token starting with the provided keyword and extract its value.
+      #
+      # @param keyword [String]
+      #
+      # @return [String] extracted value if it is found
+      # @return [nil] otherwise
+      def match(keyword)
+        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*(#{TOKEN})\z/
+
+        tokens.each do |token|
+          next unless (value = token[pattern, 1])
+
+          return value.downcase
+        end
+
+        nil
+      end
+
+      # Individual tokens composing an editor specific comment string.
+      #
+      # @return [Array<String>]
+      def tokens
+        extract(self.class::FORMAT).split(self.class::SEPARATOR).map(&:strip)
+      end
+    end
+
+    # Wrapper for Emacs style magic comments.
+    #
+    # @example Emacs style comment
+    #   comment = RuboCop::MagicComment.parse(
+    #     '# -*- encoding: ASCII-8BIT -*-'
+    #   )
+    #
+    #   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
+    class EmacsComment < EditorComment
+      FORMAT    = /\-\*\-(.+)\-\*\-/
+      SEPARATOR = ';'.freeze
+      OPERATOR  = ':'.freeze
+
+      def encoding
+        match('encoding')
+      end
+
+      private
+
+      def extract_frozen_string_literal
+        match('frozen_string_literal')
+      end
+    end
+
+    # Wrapper for Vim style magic comments.
+    #
+    # @example Vim style comment
+    #   comment = RuboCop::MagicComment.parse(
+    #     '# vim: filetype=ruby, fileencoding=ascii-8bit'
+    #   )
+    #
+    #   comment.encoding # => 'ascii-8bit'
+    class VimComment < EditorComment
+      FORMAT    = /#\s*vim:\s*(.+)/
+      SEPARATOR = ', '.freeze
+      OPERATOR  = '='.freeze
+
+      # For some reason the fileencoding keyword only works if there
+      # is at least one other token included in the string. For example
+      #
+      #    # works
+      #      # vim: foo=bar, fileencoding=ascii-8bit
+      #
+      #    # does nothing
+      #      # vim: foo=bar, fileencoding=ascii-8bit
+      #
+      def encoding
+        match('fileencoding') if tokens.size > 1
+      end
+
+      # Vim comments cannot specify frozen string literal behavior.
+      def frozen_string_literal; end
+    end
+
+    # Wrapper for regular magic comments not bound to an editor.
+    #
+    # Simple comments can only specify one setting per comment.
+    #
+    # @example frozen string literal comments
+    #   comment1 = RuboCop::MagicComment.parse('# frozen_string_literal: true')
+    #   comment1.frozen_string_literal # => true
+    #   comment1.encoding              # => nil
+    #
+    # @example encoding comments
+    #   comment2 = RuboCop::MagicComment.parse('# encoding: utf-8')
+    #   comment2.frozen_string_literal # => nil
+    #   comment2.encoding              # => 'utf-8'
+    class SimpleComment < MagicComment
+      # Match `encoding` or `coding`
+      def encoding
+        extract(/\b(?:en)?coding: (#{TOKEN})/i)
+      end
+
+      private
+
+      # Extract `frozen_string_literal`.
+      #
+      # The `frozen_string_literal` magic comment only works if it
+      # is the only text in the comment.
+      #
+      # Case-insensitive and dashes/underscores are acceptable.
+      # @see https://git.io/vM7Mg
+      def extract_frozen_string_literal
+        extract(/\A#\s*frozen[_-]string[_-]literal:\s*(#{TOKEN})\s*\z/i)
+      end
+    end
+  end
+end

data/lib/rubocop/name_similarity.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop