rubocop 0.46.0 → 0.47.0

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

@@ -9,6 +9,8 @@ module RuboCop
       class WhileUntilModifier < Cop
         include StatementModifier
 
+        MSG = 'Favor modifier `%s` usage when having a single-line body.'.freeze
+
         def on_while(node)
           check(node)
         end
@@ -17,22 +19,21 @@ module RuboCop
           check(node)
         end
 
+        private
+
         def autocorrect(node)
-          cond, body = *node
-          oneline = "#{body.source} #{node.loc.keyword.source} " + cond.source
-          ->(corrector) { corrector.replace(node.source_range, oneline) }
-        end
+          oneline = "#{node.body.source} #{node.keyword} " \
+                    "#{node.condition.source}"
 
-        private
+          lambda do |corrector|
+            corrector.replace(node.source_range, oneline)
+          end
+        end
 
         def check(node)
-          return unless node.loc.end
-          return unless single_line_as_modifier?(node)
-          add_offense(node, :keyword, message(node.loc.keyword.source))
-        end
+          return unless node.multiline? && single_line_as_modifier?(node)
 
-        def message(keyword)
-          "Favor modifier `#{keyword}` usage when having a single-line body."
+          add_offense(node, :keyword, format(MSG, node.keyword))
         end
       end
     end

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

@@ -18,7 +18,7 @@ module RuboCop
         def on_array(node)
           if bracketed_array_of?(:str, node)
             check_bracketed(node)
-          elsif percent_syntax?(node)
+          elsif node.percent_literal?(:string)
             check_percent(node)
           end
         end
@@ -34,21 +34,17 @@ module RuboCop
         private
 
         def check_bracketed(node)
-          array_elems = node.children
-
-          return if complex_content?(array_elems) ||
+          return if complex_content?(node.values) ||
                     comments_in_array?(node)
-          style_detected(:brackets, array_elems.size)
+          style_detected(:brackets, node.values.size)
 
-          return unless style == :percent && array_elems.size >= min_size
+          return unless style == :percent && node.values.size >= min_size
 
           add_offense(node, :expression, PERCENT_MSG)
         end
 
         def check_percent(node)
-          array_elems = node.children
-
-          style_detected(:percent, array_elems.size)
+          style_detected(:percent, node.values.size)
           add_offense(node, :expression, ARRAY_MSG) if style == :brackets
         end
 

data/lib/rubocop/cop/team.rb

@@ -52,7 +52,8 @@ module RuboCop
       end
 
       def cops
-        @cops ||= @cop_classes.select { |c| cop_enabled?(c) }.map do |cop_class|
+        only_options = @options.fetch(:only, [])
+        @cops ||= @cop_classes.enabled(@config, only_options).map do |cop_class|
           cop_class.new(@config, @options)
         end
       end
@@ -123,11 +124,6 @@ module RuboCop
         Investigation.new(offenses, commissioner.errors)
       end
 
-      def cop_enabled?(cop_class)
-        @config.cop_enabled?(cop_class) ||
-          (@options[:only] || []).include?(cop_class.cop_name)
-      end
-
       def autocorrect_all_cops(buffer, cops)
         corrector = Corrector.new(buffer)
         skip = Set.new
@@ -155,27 +151,32 @@ module RuboCop
 
       def process_commissioner_errors(file, file_errors)
         file_errors.each do |cop, errors|
-          errors.each do |e|
+          errors.each do |cop_error|
+            e = cop_error.error
+            line = ":#{cop_error.line}" if cop_error.line
+            column = ":#{cop_error.column}" if cop_error.column
+            location = "#{file}#{line}#{column}"
+
             if e.is_a?(Warning)
-              handle_warning(e,
-                             Rainbow("#{e.message} (from file: " \
-                             "#{file})").yellow)
+              handle_warning(e, location)
             else
-              handle_error(e,
-                           Rainbow("An error occurred while #{cop.name}" \
-                           " cop was inspecting #{file}.").red)
+              handle_error(e, location, cop)
             end
           end
         end
       end
 
-      def handle_warning(e, message)
+      def handle_warning(e, location)
+        message = Rainbow("#{e.message} (from file: #{location})").yellow
+
         @warnings << message
         warn message
         puts e.backtrace if debug?
       end
 
-      def handle_error(e, message)
+      def handle_error(e, location, cop)
+        message = Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{location}.").red
         @errors << message
         warn message
         if debug?

data/lib/rubocop/cop/util.rb

@@ -6,7 +6,7 @@ module RuboCop
     # This module contains a collection of useful utility methods.
     module Util
       include PathUtil
-      extend RuboCop::Sexp
+      extend RuboCop::AST::Sexp
 
       BYTE_ORDER_MARK = 0xfeff # The Unicode codepoint
 
@@ -15,6 +15,10 @@ module RuboCop
       SHORTHAND_ASGN_NODES = [:op_asgn, :or_asgn, :and_asgn].freeze
       ASGN_NODES = (EQUALS_ASGN_NODES + SHORTHAND_ASGN_NODES).freeze
 
+      MODIFIER_NODES = [:if, :while, :until].freeze
+      CONDITIONAL_NODES = (MODIFIER_NODES + [:case]).freeze
+      LOGICAL_OPERATOR_NODES = [:and, :or].freeze
+
       # http://phrogz.net/programmingruby/language.html#table_18.4
       # Backtick is added last just to help editors parse this code.
       OPERATOR_METHODS = %w(
@@ -172,8 +176,8 @@ module RuboCop
       end
 
       def within_node?(inner, outer)
-        o = outer.is_a?(Node) ? outer.source_range : outer
-        i = inner.is_a?(Node) ? inner.source_range : inner
+        o = outer.is_a?(AST::Node) ? outer.source_range : outer
+        i = inner.is_a?(AST::Node) ? inner.source_range : inner
         i.begin_pos >= o.begin_pos && i.end_pos <= o.end_pos
       end
 
@@ -271,6 +275,12 @@ module RuboCop
         src = src.dup if RUBY_VERSION < '2.3'
         src.force_encoding(Encoding.default_external).valid_encoding?
       end
+
+      def to_supported_styles(enforced_style)
+        enforced_style
+          .sub(/^Enforced/, 'Supported')
+          .sub('Style', 'Styles')
+      end
     end
   end
 end

data/lib/rubocop/formatter/clang_style_formatter.rb

@@ -6,7 +6,7 @@ module RuboCop
     # The precise location of the problem is shown together with the
     # relevant source code.
     class ClangStyleFormatter < SimpleTextFormatter
-      ELLIPSES = Rainbow('...').yellow.freeze
+      ELLIPSES = '...'.freeze
 
       def report_file(file, offenses)
         offenses.each { |offense| report_offense(file, offense) }
@@ -41,7 +41,7 @@ module RuboCop
         if location.first_line == location.last_line
           output.puts(source_line)
         else
-          output.puts("#{source_line} #{ELLIPSES}")
+          output.puts("#{source_line} #{yellow(ELLIPSES)}")
         end
       end
 

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -18,7 +18,7 @@ module RuboCop
       @config_to_allow_offenses = {}
       @detected_styles = {}
 
-      COPS = Cop::Cop.all.group_by(&:cop_name)
+      COPS = Cop::Cop.registry.to_h
 
       class << self
         attr_accessor :config_to_allow_offenses, :detected_styles
@@ -66,6 +66,7 @@ module RuboCop
         if @exclude_limit_option
           command += format(' --exclude-limit %d', @exclude_limit_option.to_i)
         end
+        command += ' --no-offense-counts' if @options[:no_offense_counts]
 
         command
       end

data/lib/rubocop/magic_comment.rb

@@ -0,0 +1,196 @@
+# 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
+
+    # 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?
+      !frozen_string_literal.nil?
+    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
+
+    private
+
+    # 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; frozen_string_literal: true -*-'
+    #   )
+    #
+    #   comment.encoding              # => 'ascii-8bit'
+    #   comment.frozen_string_literal # => true
+    #
+    # @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})/)
+      end
+
+      private
+
+      # Extract `frozen_string_literal`.
+      #
+      # The `frozen_string_literal` magic comment only works if it
+      # is the only text in the comment.
+      def extract_frozen_string_literal
+        extract(/^#\s*frozen_string_literal:\s*(#{TOKEN})\s*$/)
+      end
+    end
+  end
+end

data/lib/rubocop/options.rb

@@ -179,13 +179,14 @@ module RuboCop
     def self.validate_cop_list(names)
       return unless names
 
-      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
+      departments = Cop::Cop.registry.departments.map(&:to_s)
+
       names.each do |name|
-        next if Cop::Cop.all.any? { |c| c.cop_name == name }
-        next if namespaces.include?(name)
+        next if Cop::Cop.registry.names.include?(name)
+        next if departments.include?(name)
         next if %w(Syntax Lint/Syntax).include?(name)
 
-        raise ArgumentError, "Unrecognized cop or namespace: #{name}."
+        raise ArgumentError, "Unrecognized cop or department: #{name}."
       end
     end
 

data/lib/rubocop/processed_source.rb

@@ -133,7 +133,7 @@ module RuboCop
     end
 
     def create_parser(ruby_version)
-      builder = RuboCop::Node::Builder.new
+      builder = RuboCop::AST::Builder.new
 
       parser_class(ruby_version).new(builder).tap do |parser|
         # On JRuby and Rubinius, there's a risk that we hang in tokenize() if we

data/lib/rubocop/rspec/cop_helper.rb

@@ -53,6 +53,15 @@ module CopHelper
     corrector.rewrite
   end
 
+  def autocorrect_source_with_loop(cop, source, file = nil)
+    loop do
+      cop.instance_variable_set(:@corrections, [])
+      new_source = autocorrect_source(cop, source, file)
+      return new_source if new_source == source
+      source = new_source
+    end
+  end
+
   def _investigate(cop, processed_source)
     forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
       next unless cop.join_force?(klass)