rubocop 0.49.1 → 0.52.0

data/lib/rubocop/ast/node/str_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `str`, `dstr` and `xstr` nodes. This will be used
+    # in place of a plain node when the builder constructs the AST, making
+    # its methods available to all `str` nodes within RuboCop.
+    class StrNode < Node
+      def heredoc?
+        loc.is_a?(Parser::Source::Map::Heredoc)
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/super_node.rb

@@ -7,35 +7,14 @@ module RuboCop
     # methods available to all `super`- and `zsuper` nodes within RuboCop.
     class SuperNode < Node
       include ParameterizedNode
-
-      # The method name of this `super` node. Always `:super`.
-      #
-      # @return [Symbol] the method name of `super`
-      def method_name
-        :super
-      end
-
-      # An array containing the arguments of the super invocation.
-      #
-      # @return [Array<Node>] the arguments of the super invocation
-      def arguments
-        node_parts
-      end
-
-      # Checks whether the method name matches the argument.
-      #
-      # @param [Symbol, String] name the method name to check for
-      # @return [Boolean] whether the method name matches the argument
-      def method?(name)
-        method_name == name.to_sym
-      end
+      include MethodDispatchNode
 
       # Custom destructuring method. This can be used to normalize
       # destructuring for different variations of the node.
       #
-      # @return [Array] the different parts of the `block` node
+      # @return [Array] the different parts of the `super` node
       def node_parts
-        to_a
+        [nil, :super, *to_a]
       end
     end
   end

data/lib/rubocop/ast/node/symbol_node.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `sym` nodes. This will be used in  place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `sym` nodes within RuboCop.
+    class SymbolNode < Node
+      include BasicLiteralNode
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `sym` node
+      def node_parts
+        to_a
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/yield_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `yield` nodes. This will be used in place of a plain
+    # node when the builder constructs the AST, making its methods available
+    # to all `yield` nodes within RuboCop.
+    class YieldNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # Custom destructuring method. This can be used to normalize
+      # destructuring for different variations of the node.
+      #
+      # @return [Array] the different parts of the `send` node
+      def node_parts
+        [nil, :yield, *to_a]
+      end
+    end
+  end
+end

data/lib/rubocop/ast/traversal.rb

@@ -30,37 +30,37 @@ module RuboCop
                              kwoptarg].freeze
 
       NO_CHILD_NODES.each do |type|
-        module_eval("def on_#{type}(node); end")
+        module_eval("def on_#{type}(node); end", __FILE__, __LINE__)
       end
 
       ONE_CHILD_NODE.each do |type|
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             if (child = node.children[0])
               send(:"on_\#{child.type}", child)
             end
           end
-        END
+        RUBY
       end
 
       MANY_CHILD_NODES.each do |type|
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             node.children.each { |child| send(:"on_\#{child.type}", child) }
             nil
           end
-        END
+        RUBY
       end
 
       SECOND_CHILD_ONLY.each do |type|
         # Guard clause is for nodes nested within mlhs
-        module_eval(<<-END)
+        module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def on_#{type}(node)
             if (child = node.children[1])
               send(:"on_\#{child.type}", child)
             end
           end
-        END
+        RUBY
       end
 
       def on_const(node)

data/lib/rubocop/cached_data.rb

@@ -38,12 +38,7 @@ module RuboCop
     def message(offense)
       # JSON.dump will fail if the offense message contains text which is not
       # valid UTF-8
-      message = offense.message
-      if message.respond_to?(:scrub)
-        message.scrub
-      else
-        message.chars.select(&:valid_encoding?).join
-      end
+      offense.message.scrub
     end
 
     # Restore an offense object loaded from a JSON file.

data/lib/rubocop/cli.rb

@@ -15,25 +15,28 @@ module RuboCop
       @config_store = ConfigStore.new
     end
 
+    # @api public
+    #
     # Entry point for the application logic. Here we
     # do the command line arguments processing and inspect
-    # the target files
+    # the target files.
+    #
+    # @param args [Array<String>] command line arguments
     # @return [Integer] UNIX exit code
     def run(args = ARGV)
       @options, paths = Options.new.parse(args)
       validate_options_vs_config
       act_on_options
       apply_default_formatter
-
-      execute_runner(paths)
+      execute_runners(paths)
     rescue RuboCop::Error => e
-      $stderr.puts Rainbow("Error: #{e.message}").red
+      warn Rainbow("Error: #{e.message}").red
       return 2
     rescue Finished
       return 0
-    rescue StandardError, SyntaxError => e
-      $stderr.puts e.message
-      $stderr.puts e.backtrace
+    rescue StandardError, SyntaxError, LoadError => e
+      warn e.message
+      warn e.backtrace
       return 2
     end
 
@@ -41,13 +44,55 @@ module RuboCop
       Signal.trap('INT') do
         exit!(1) if runner.aborting?
         runner.abort
-        $stderr.puts
-        $stderr.puts 'Exiting... Interrupt again to exit immediately.'
+        warn
+        warn 'Exiting... Interrupt again to exit immediately.'
       end
     end
 
     private
 
+    def execute_runners(paths)
+      if @options[:auto_gen_config]
+        reset_config_and_auto_gen_file
+        line_length_contents = run_line_length_cop_auto_gen_config(paths)
+        run_all_cops_auto_gen_config(line_length_contents, paths)
+      else
+        execute_runner(paths)
+      end
+    end
+
+    # Do an initial run with only Metrics/LineLength so that cops that depend
+    # on Metrics/LineLength:Max get the correct value for that parameter.
+    def run_line_length_cop_auto_gen_config(paths)
+      puts Rainbow('Phase 1 of 2: run Metrics/LineLength cop').yellow
+      @options[:only] = ['Metrics/LineLength']
+      execute_runner(paths)
+      @options.delete(:only)
+      @config_store = ConfigStore.new
+      # Save the todo configuration of the LineLength cop.
+      IO.read(ConfigLoader::AUTO_GENERATED_FILE)
+        .lines
+        .drop_while { |line| line.start_with?('#') }
+        .join
+    end
+
+    def run_all_cops_auto_gen_config(line_length_contents, paths)
+      puts Rainbow('Phase 2 of 2: run all cops').yellow
+      result = execute_runner(paths)
+      # This run was made with the current maximum length allowed, so append
+      # the saved setting for LineLength.
+      File.open(ConfigLoader::AUTO_GENERATED_FILE, 'a') do |f|
+        f.write(line_length_contents)
+      end
+      result
+    end
+
+    def reset_config_and_auto_gen_file
+      @config_store = ConfigStore.new
+      File.open(ConfigLoader::AUTO_GENERATED_FILE, 'w'){}
+      ConfigLoader.add_inheritance_from_auto_generated_file
+    end
+
     def validate_options_vs_config
       if @options[:parallel] &&
          !@config_store.for(Dir.pwd).for_all_cops['UseCache']
@@ -58,14 +103,15 @@ module RuboCop
     end
 
     def act_on_options
-      handle_exiting_options
-
       ConfigLoader.debug = @options[:debug]
       ConfigLoader.auto_gen_config = @options[:auto_gen_config]
+      ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
 
       @config_store.options_config = @options[:config] if @options[:config]
       @config_store.force_default_config! if @options[:force_default_config]
 
+      handle_exiting_options
+
       if @options[:color]
         # color output explicitly forced on
         Rainbow.enabled = true
@@ -177,12 +223,12 @@ module RuboCop
 
       errors.each { |error| warn error }
 
-      warn <<-END.strip_indent
+      warn <<-WARNING.strip_indent
         Errors are usually caused by RuboCop bugs.
         Please, report your problems to RuboCop's issue tracker.
         Mention the following information in the issue report:
         #{RuboCop::Version.version(true)}
-      END
+      WARNING
     end
 
     def maybe_print_corrected_source

data/lib/rubocop/comment_config.rb

@@ -144,11 +144,8 @@ module RuboCop
 
     def non_comment_token_line_numbers
       @non_comment_token_line_numbers ||= begin
-        non_comment_tokens = processed_source.tokens.reject do |token|
-          token.type == :tCOMMENT
-        end
-
-        non_comment_tokens.map { |token| token.pos.line }.uniq
+        non_comment_tokens = processed_source.tokens.reject(&:comment?)
+        non_comment_tokens.map(&:line).uniq
       end
     end
   end

data/lib/rubocop/config.rb

@@ -2,14 +2,14 @@
 
 require 'pathname'
 
-# rubocop:disable Metrics/ClassLength
-
 module RuboCop
   # This class represents the configuration of the RuboCop application
   # and all its cops. A Config is associated with a YAML configuration
   # file from which it was read. Several different Configs can be used
   # during a run of the rubocop program, if files in several
   # directories are inspected.
+
+  # rubocop:disable Metrics/ClassLength
   class Config
     include PathUtil
 
@@ -17,7 +17,8 @@ module RuboCop
                        AutoCorrect StyleGuide Details].freeze
     # 2.1 is the oldest officially supported Ruby version.
     DEFAULT_RUBY_VERSION = 2.1
-    KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3, 2.4].freeze
+    KNOWN_RUBIES = [2.1, 2.2, 2.3, 2.4, 2.5].freeze
+    OBSOLETE_RUBIES = { 1.9 => '0.50', 2.0 => '0.50' }.freeze
     DEFAULT_RAILS_VERSION = 5.0
     OBSOLETE_COPS = {
       'Style/TrailingComma' =>
@@ -26,9 +27,15 @@ module RuboCop
         '`Style/TrailingCommaInArguments` instead.',
       'Rails/DefaultScope' =>
         'The `Rails/DefaultScope` cop no longer exists.',
+      'Lint/InvalidCharacterLiteral' =>
+        'The `Lint/InvalidCharacterLiteral` cop has been removed since it ' \
+        'was never being actually triggered.',
       'Style/SingleSpaceBeforeFirstArg' =>
         'The `Style/SingleSpaceBeforeFirstArg` cop has been renamed to ' \
         '`Layout/SpaceBeforeFirstArg`.',
+      'Lint/RescueWithoutErrorClass' =>
+        'The `Lint/RescueWithoutErrorClass` cop has been replaced by ' \
+        '`Style/RescueStandardError`.',
       'Lint/SpaceBeforeFirstArg' =>
         'The `Lint/SpaceBeforeFirstArg` cop has been removed, since it was a ' \
         'duplicate of `Layout/SpaceBeforeFirstArg`. Please use ' \
@@ -52,7 +59,36 @@ module RuboCop
         'The `Lint/Eval` cop has been renamed to `Security/Eval`.',
       'Style/DeprecatedHashMethods' =>
         'The `Style/DeprecatedHashMethods` cop has been renamed to ' \
-          '`Style/PreferredHashMethods`.'
+          '`Style/PreferredHashMethods`.',
+      'Style/AccessorMethodName' =>
+        'The `Style/AccessorMethodName` cop has been moved to ' \
+          '`Naming/AccessorMethodName`.',
+      'Style/AsciiIdentifiers' =>
+        'The `Style/AsciiIdentifiers` cop has been moved to ' \
+          '`Naming/AccessorMethodName`.',
+      'Style/OpMethod' =>
+        'The `Style/OpMethod` cop has been renamed and moved to ' \
+          '`Naming/BinaryOperatorParameterName`.',
+      'Style/ClassAndModuleCamelCase' =>
+        'The `Style/ClassAndModuleCamelCase` cop has been renamed to ' \
+          '`Naming/ClassAndModuleCamelCase`.',
+      'Style/ConstantName' =>
+        'The `Style/ConstantName` cop has been renamed to ' \
+          '`Naming/ConstantName`.',
+      'Style/FileName' =>
+        'The `Style/FileName` cop has been renamed to `Naming/FileName`.',
+      'Style/MethodName' =>
+        'The `Style/MethodName` cop has been renamed to ' \
+          '`Naming/MethodName`.',
+      'Style/PredicateName' =>
+        'The `Style/PredicateName` cop has been renamed to ' \
+          '`Naming/PredicateName`.',
+      'Style/VariableName' =>
+        'The `Style/VariableName` cop has been renamed to ' \
+          '`Naming/VariableName`.',
+      'Style/VariableNumber' =>
+        'The `Style/VariableNumber` cop has been renamed to ' \
+          '`Naming/VariableNumber`.'
     }.freeze
 
     OBSOLETE_PARAMETERS = [
@@ -63,6 +99,31 @@ module RuboCop
                      'for alignment, please use AllowForAlignment: ' \
                      'true instead.'
       },
+      {
+        cop: 'Style/Encoding',
+        parameter: 'EnforcedStyle',
+        alternative: 'Style/Encoding no longer supports styles. ' \
+                     'The "never" behavior is always assumed.'
+      },
+      {
+        cop: 'Style/Encoding',
+        parameter: 'SupportedStyles',
+        alternative: 'Style/Encoding no longer supports styles. ' \
+                     'The "never" behavior is always assumed.'
+      },
+      {
+        cop: 'Style/Encoding',
+        parameter: 'AutoCorrectEncodingComment',
+        alternative: 'Style/Encoding no longer supports styles. ' \
+                     'The "never" behavior is always assumed.'
+      },
+      {
+        cop: 'Style/IfUnlessModifier',
+        parameter: 'MaxLineLength',
+        alternative:
+          '`Style/IfUnlessModifier: MaxLineLength` has been removed. Use ' \
+          '`Metrics/LineLength: Max` instead'
+      },
       {
         cop: 'Style/SpaceAroundOperators',
         parameter: 'MultiSpaceAllowedForOperators',
@@ -70,6 +131,13 @@ module RuboCop
                      'for alignment, please use AllowForAlignment: ' \
                      'true instead.'
       },
+      {
+        cop: 'Style/WhileUntilModifier',
+        parameter: 'MaxLineLength',
+        alternative:
+          '`Style/WhileUntilModifier: MaxLineLength` has been removed. Use ' \
+          '`Metrics/LineLength: Max` instead'
+      },
       {
         cop: 'AllCops',
         parameter: 'RunRailsCops',
@@ -121,6 +189,19 @@ module RuboCop
       @hash = hash
     end
 
+    def self.create(hash, path)
+      new(hash, path).check
+    end
+
+    def check
+      deprecation_check do |deprecation_message|
+        warn("#{path} - #{deprecation_message}")
+      end
+      validate
+      make_excludes_absolute
+      self
+    end
+
     def [](key)
       @hash[key]
     end
@@ -145,6 +226,10 @@ module RuboCop
       @hash.keys
     end
 
+    def each_key(&block)
+      @hash.each_key(&block)
+    end
+
     def map(&block)
       @hash.map(&block)
     end
@@ -166,7 +251,7 @@ module RuboCop
     end
 
     def make_excludes_absolute
-      each do |key, _|
+      each_key do |key|
         validate_section_presence(key)
         next unless self[key]['Exclude']
 
@@ -227,6 +312,7 @@ module RuboCop
       check_target_ruby
       validate_parameter_names(valid_cop_names)
       validate_enforced_styles(valid_cop_names)
+      validate_syntax_cop
       reject_mutually_exclusive_defaults
     end
 
@@ -317,23 +403,30 @@ module RuboCop
 
     def warn_about_unrecognized_cops(invalid_cop_names)
       invalid_cop_names.each do |name|
-        if name == 'Syntax'
-          raise ValidationError,
-                "configuration for Syntax cop found in #{loaded_path}\n" \
-                'This cop cannot be configured.'
-        end
-
         # There could be a custom cop with this name. If so, don't warn
         next if Cop::Cop.registry.contains_cop_matching?([name])
 
         warn Rainbow("Warning: unrecognized cop #{name} found in " \
-                     "#{loaded_path}").yellow
+                     "#{smart_loaded_path}").yellow
       end
     end
 
+    def validate_syntax_cop
+      syntax_config = self['Lint/Syntax']
+      default_config = ConfigLoader.default_configuration['Lint/Syntax']
+
+      return unless syntax_config &&
+                    default_config.merge(syntax_config) != default_config
+
+      raise ValidationError,
+            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
+            'It\'s not possible to disable this cop.'
+    end
+
     def validate_section_presence(name)
       return unless key?(name) && self[name].nil?
-      raise ValidationError, "empty section #{name} found in #{loaded_path}"
+      raise ValidationError,
+            "empty section #{name} found in #{smart_loaded_path}"
     end
 
     def validate_parameter_names(valid_cop_names)
@@ -344,7 +437,7 @@ module RuboCop
                   ConfigLoader.default_configuration[name].key?(param)
 
           warn Rainbow("Warning: unrecognized parameter #{name}:#{param} " \
-                       "found in #{loaded_path}").yellow
+                       "found in #{smart_loaded_path}").yellow
         end
       end
     end
@@ -360,7 +453,7 @@ module RuboCop
           next if valid.include?(style)
 
           msg = "invalid #{style_name} '#{style}' for #{name} found in " \
-            "#{loaded_path}\n" \
+            "#{smart_loaded_path}\n" \
             "Valid choices are: #{valid.join(', ')}"
           raise ValidationError, msg
         end
@@ -388,36 +481,45 @@ module RuboCop
       return unless self[cop] && self[cop].key?(parameter)
 
       "obsolete parameter #{parameter} (for #{cop}) " \
-        "found in #{loaded_path}" \
+        "found in #{smart_loaded_path}" \
         "\n#{alternative}"
     end
 
     def obsolete_cops
       OBSOLETE_COPS.map do |cop_name, message|
         next unless key?(cop_name) || key?(Cop::Badge.parse(cop_name).cop_name)
-        message + "\n(obsolete configuration found in #{loaded_path}, please" \
-                   ' update it)'
+        message + "\n(obsolete configuration found in #{smart_loaded_path}," \
+                   ' please update it)'
       end
     end
 
     def check_target_ruby
       return if KNOWN_RUBIES.include?(target_ruby_version)
 
-      msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
-
-      msg +=
-        case @target_ruby_version_source
-        when :dot_ruby_version
-          'in `.ruby-version`.'
-        when :rubocop_yml
-          "in `TargetRubyVersion` parameter (in #{loaded_path})." \
-        end
+      msg = if OBSOLETE_RUBIES.include?(target_ruby_version)
+              "Unsupported Ruby version #{target_ruby_version} found in " \
+              "#{target_ruby_source}. #{target_ruby_version}-compatible " \
+              'analysis was dropped after version ' \
+              "#{OBSOLETE_RUBIES[target_ruby_version]}."
+            else
+              "Unknown Ruby version #{target_ruby_version.inspect} found in " \
+              "#{target_ruby_source}."
+            end
 
-      msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
+      msg += "\nSupported versions: #{KNOWN_RUBIES.join(', ')}"
 
       raise ValidationError, msg
     end
 
+    def target_ruby_source
+      case @target_ruby_version_source
+      when :dot_ruby_version
+        '`.ruby-version`'
+      when :rubocop_yml
+        "`TargetRubyVersion` parameter (in #{smart_loaded_path})"
+      end
+    end
+
     def reject_mutually_exclusive_defaults
       disabled_by_default = for_all_cops['DisabledByDefault']
       enabled_by_default = for_all_cops['EnabledByDefault']
@@ -433,12 +535,17 @@ module RuboCop
 
       unless department
         department_options = self[cop_department]
-        if department_options && department_options.fetch('Enabled') == false
+        if department_options && department_options['Enabled'] == false
           return false
         end
       end
 
       cop_options.fetch('Enabled', true)
     end
+
+    def smart_loaded_path
+      PathUtil.smart_path(@loaded_path)
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end