rubocop 1.10.0 → 1.14.0

data/lib/rubocop/cli/command/show_cops.rb

@@ -26,10 +26,7 @@ module RuboCop
           registry = Cop::Registry.global
           show_all = @options[:show_cops].empty?
 
-          if show_all
-            puts "# Available cops (#{registry.length}) " \
-                 "+ config for #{Dir.pwd}: "
-          end
+          puts "# Available cops (#{registry.length}) + config for #{Dir.pwd}: " if show_all
 
           registry.departments.sort!.each do |department|
             print_cops_of_department(registry, department, show_all)

data/lib/rubocop/cli/command/suggest_extensions.rb

@@ -22,7 +22,7 @@ module RuboCop
             'RuboCop extension libraries might be helpful:'
 
           extensions.sort.each do |extension|
-            puts "  * #{extension} (http://github.com/rubocop-hq/#{extension})"
+            puts "  * #{extension} (https://github.com/rubocop/#{extension})"
           end
 
           puts
@@ -43,7 +43,8 @@ module RuboCop
           # 2. When given RuboCop options that it doesn't make sense for
           # 3. For all formatters except specified in `INCLUDED_FORMATTERS'`
           ENV['CI'] ||
-            @options[:only] || @options[:debug] || @options[:list_target_files] || @options[:out] ||
+            @options[:only] || @options[:debug] || @options[:list_target_files] ||
+            @options[:out] || @options[:stdin] ||
             !INCLUDED_FORMATTERS.include?(current_formatter)
         end
 

data/lib/rubocop/comment_config.rb

@@ -4,22 +4,6 @@ module RuboCop
   # This class parses the special `rubocop:disable` comments in a source
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
-    # @api private
-    REDUNDANT_DISABLE = 'Lint/RedundantCopDisableDirective'
-
-    # @api private
-    COP_NAME_PATTERN = '([A-Z]\w+/)*(?:[A-Z]\w+)'
-    # @api private
-    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
-    # @api private
-    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
-
-    # @api private
-    COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      "# rubocop : ((?:disable|enable|todo))\\b #{COPS_PATTERN}"
-        .gsub(' ', '\s*')
-    )
-
     CopAnalysis = Struct.new(:line_ranges, :start_line_number)
 
     attr_reader :processed_source
@@ -41,28 +25,23 @@ module RuboCop
     end
 
     def extra_enabled_comments
-      extra_enabled_comments_with_names(
-        extras: Hash.new { |h, k| h[k] = [] },
-        names: Hash.new(0)
-      )
+      extra_enabled_comments_with_names(extras: Hash.new { |h, k| h[k] = [] }, names: Hash.new(0))
     end
 
     def comment_only_line?(line_number)
-      non_comment_token_line_numbers.none? do |non_comment_line_number|
-        non_comment_line_number == line_number
-      end
+      non_comment_token_line_numbers.none?(line_number)
     end
 
     private
 
     def extra_enabled_comments_with_names(extras:, names:)
-      each_directive do |comment, cop_names, disabled|
-        next unless comment_only_line?(comment.loc.expression.line)
+      each_directive do |directive|
+        next unless comment_only_line?(directive.line_number)
 
-        if !disabled && enable_all?(comment)
-          handle_enable_all(names, extras, comment)
+        if directive.enabled_all?
+          handle_enable_all(directive, names, extras)
         else
-          handle_switch(cop_names, names, disabled, extras, comment)
+          handle_switch(directive, names, extras)
         end
       end
 
@@ -72,9 +51,11 @@ module RuboCop
     def analyze # rubocop:todo Metrics/AbcSize
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
 
-      each_mentioned_cop do |cop_name, disabled, line, single_line|
-        analyses[cop_name] =
-          analyze_cop(analyses[cop_name], disabled, line, single_line)
+      each_directive do |directive|
+        directive.cop_names.each do |cop_name|
+          cop_name = qualified_cop_name(cop_name)
+          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        end
       end
 
       analyses.each_with_object({}) do |element, hash|
@@ -83,37 +64,42 @@ module RuboCop
       end
     end
 
-    def analyze_cop(analysis, disabled, line, single_line)
-      if single_line
-        analyze_single_line(analysis, line, disabled)
-      elsif disabled
-        analyze_disabled(analysis, line)
+    def analyze_cop(analysis, directive)
+      # Disabling cops after comments like `#=SomeDslDirective` does not related to single line
+      if !comment_only_line?(directive.line_number) || directive.single_line?
+        analyze_single_line(analysis, directive)
+      elsif directive.disabled?
+        analyze_disabled(analysis, directive)
       else
-        analyze_rest(analysis, line)
+        analyze_rest(analysis, directive)
       end
     end
 
-    def analyze_single_line(analysis, line, disabled)
-      return analysis unless disabled
+    def analyze_single_line(analysis, directive)
+      return analysis unless directive.disabled?
+
+      line = directive.line_number
+      start_line = analysis.start_line_number
 
-      CopAnalysis.new(analysis.line_ranges + [(line..line)],
-                      analysis.start_line_number)
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
     end
 
-    def analyze_disabled(analysis, line)
-      if (start_line = analysis.start_line_number)
-        # Cop already disabled on this line, so we end the current disabled
-        # range before we start a new range.
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
-      end
+    def analyze_disabled(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      # Cop already disabled on this line, so we end the current disabled
+      # range before we start a new range.
+      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
 
       CopAnalysis.new(analysis.line_ranges, line)
     end
 
-    def analyze_rest(analysis, line)
-      if (start_line = analysis.start_line_number)
-        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
-      end
+    def analyze_rest(analysis, directive)
+      line = directive.line_number
+      start_line = analysis.start_line_number
+
+      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
 
       CopAnalysis.new(analysis.line_ranges, nil)
     end
@@ -124,54 +110,17 @@ module RuboCop
       analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
     end
 
-    def each_mentioned_cop
-      each_directive do |comment, cop_names, disabled|
-        comment_line_number = comment.loc.expression.line
-        single_line = !comment_only_line?(comment_line_number) ||
-                      directive_on_comment_line?(comment)
-
-        cop_names.each do |cop_name|
-          yield qualified_cop_name(cop_name), disabled, comment_line_number,
-                single_line
-        end
-      end
-    end
-
-    def directive_on_comment_line?(comment)
-      comment.text[1..-1].match?(COMMENT_DIRECTIVE_REGEXP)
-    end
-
     def each_directive
       processed_source.comments.each do |comment|
-        directive = directive_parts(comment)
-        next unless directive
-
-        yield comment, *directive
+        directive = DirectiveComment.new(comment)
+        yield directive if directive.cop_names
       end
     end
 
-    def directive_parts(comment)
-      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
-      return unless match
-
-      switch, cops_string = match.captures
-
-      cop_names =
-        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
-
-      disabled = %w[disable todo].include?(switch)
-
-      [cop_names, disabled]
-    end
-
     def qualified_cop_name(cop_name)
       Cop::Registry.qualified_cop_name(cop_name.strip, processed_source.file_path)
     end
 
-    def all_cop_names
-      @all_cop_names ||= Cop::Registry.global.names - [REDUNDANT_DISABLE]
-    end
-
     def non_comment_token_line_numbers
       @non_comment_token_line_numbers ||= begin
         non_comment_tokens = processed_source.tokens.reject(&:comment?)
@@ -179,12 +128,7 @@ module RuboCop
       end
     end
 
-    def enable_all?(comment)
-      _, cops = comment.text.match(COMMENT_DIRECTIVE_REGEXP).captures
-      cops == 'all'
-    end
-
-    def handle_enable_all(names, extras, comment)
+    def handle_enable_all(directive, names, extras)
       enabled_cops = 0
       names.each do |name, counter|
         next unless counter.positive?
@@ -193,19 +137,19 @@ module RuboCop
         enabled_cops += 1
       end
 
-      extras[comment] << 'all' if enabled_cops.zero?
+      extras[directive.comment] << 'all' if enabled_cops.zero?
     end
 
     # Collect cops that have been disabled or enabled by name in a directive comment
     # so that `Lint/RedundantCopEnableDirective` can register offenses correctly.
-    def handle_switch(cop_names, names, disabled, extras, comment)
-      cop_names.each do |name|
-        if disabled
+    def handle_switch(directive, names, extras)
+      directive.cop_names.each do |name|
+        if directive.disabled?
           names[name] += 1
         elsif (names[name]).positive?
           names[name] -= 1
         else
-          extras[comment] << name
+          extras[directive.comment] << name
         end
       end
     end

data/lib/rubocop/config.rb

@@ -45,9 +45,7 @@ module RuboCop
     end
 
     def check
-      deprecation_check do |deprecation_message|
-        warn("#{loaded_path} - #{deprecation_message}")
-      end
+      deprecation_check { |deprecation_message| warn("#{loaded_path} - #{deprecation_message}") }
       @validator.validate
       make_excludes_absolute
       self
@@ -67,8 +65,7 @@ module RuboCop
 
     # True if this is a config file that is shipped with RuboCop
     def internal?
-      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME,
-                                                    'config'))
+      base_config_path = File.expand_path(File.join(ConfigLoader::RUBOCOP_HOME, 'config'))
       File.expand_path(loaded_path).start_with?(base_config_path)
     end
 
@@ -79,8 +76,7 @@ module RuboCop
 
         self[key]['Exclude'].map! do |exclude_elem|
           if exclude_elem.is_a?(String) && !absolute?(exclude_elem)
-            File.expand_path(File.join(base_dir_for_path_parameters,
-                                       exclude_elem))
+            File.expand_path(File.join(base_dir_for_path_parameters, exclude_elem))
           else
             exclude_elem
           end
@@ -122,17 +118,14 @@ module RuboCop
     # Note: the 'Enabled' attribute is same as that returned by `for_cop`
     def for_badge(badge)
       cop_config = for_cop(badge.to_s)
-      fetch(badge.department.to_s) { return cop_config }
-        .merge(cop_config)
+      fetch(badge.department.to_s) { return cop_config }.merge(cop_config)
     end
 
     # @return [Config] for the given department name.
     # Note: the 'Enabled' attribute will be present only if specified
     # at the department's level
     def for_department(department_name)
-      @for_department ||= Hash.new do |h, dept|
-        h[dept] = self[dept] || {}
-      end
+      @for_department ||= Hash.new { |h, dept| h[dept] = self[dept] || {} }
       @for_department[department_name.to_s]
     end
 
@@ -153,8 +146,7 @@ module RuboCop
 
       # Optimization to quickly decide if the given file is hidden (on the top
       # level) and cannot be matched by any pattern.
-      is_hidden = relative_file_path.start_with?('.') &&
-                  !relative_file_path.start_with?('..')
+      is_hidden = relative_file_path.start_with?('.') && !relative_file_path.start_with?('..')
       return false if is_hidden && !possibly_include_hidden?
 
       absolute_file_path = File.expand_path(file)
@@ -163,8 +155,7 @@ module RuboCop
         if block_given?
           yield pattern, relative_file_path, absolute_file_path
         else
-          match_path?(pattern, relative_file_path) ||
-            match_path?(pattern, absolute_file_path)
+          match_path?(pattern, relative_file_path) || match_path?(pattern, absolute_file_path)
         end
       end
     end
@@ -177,8 +168,7 @@ module RuboCop
 
       file_to_include?(file) do |pattern, relative_path, absolute_path|
         /[A-Z]/.match?(pattern.to_s) &&
-          (match_path?(pattern, relative_path) ||
-           match_path?(pattern, absolute_path))
+          (match_path?(pattern, relative_path) || match_path?(pattern, absolute_path))
       end
     end
 
@@ -194,9 +184,7 @@ module RuboCop
 
     def file_to_exclude?(file)
       file = File.expand_path(file)
-      patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file)
-      end
+      patterns_to_exclude.any? { |pattern| match_path?(pattern, file) }
     end
 
     def patterns_to_include
@@ -267,8 +255,7 @@ module RuboCop
     private
 
     def target_rails_version_from_bundler_lock_file
-      @target_rails_version_from_bundler_lock_file ||=
-        read_rails_version_from_bundler_lock_file
+      @target_rails_version_from_bundler_lock_file ||= read_rails_version_from_bundler_lock_file
     end
 
     def read_rails_version_from_bundler_lock_file
@@ -288,9 +275,7 @@ module RuboCop
       return true if cop_options['Enabled'] == true
 
       department = department_of(qualified_cop_name)
-      cop_enabled = cop_options.fetch('Enabled') do
-        !for_all_cops['DisabledByDefault']
-      end
+      cop_enabled = cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
       return true if cop_enabled == 'override_department'
       return false if department && department['Enabled'] == false
 

data/lib/rubocop/config_loader.rb

@@ -22,8 +22,7 @@ module RuboCop
     class << self
       include FileFinder
 
-      attr_accessor :debug, :ignore_parent_exclusion,
-                    :disable_pending_cops, :enable_pending_cops
+      attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops
       attr_writer :default_configuration, :project_root
       attr_reader :loaded_features
 
@@ -58,9 +57,7 @@ module RuboCop
 
       def load_yaml_configuration(absolute_path)
         file_contents = read_file(absolute_path)
-        yaml_code = Dir.chdir(File.dirname(absolute_path)) do
-          ERB.new(file_contents).result
-        end
+        yaml_code = Dir.chdir(File.dirname(absolute_path)) { ERB.new(file_contents).result }
         check_duplication(yaml_code, absolute_path)
         hash = yaml_safe_load(yaml_code, absolute_path) || {}
 
@@ -156,9 +153,7 @@ module RuboCop
 
         warn Rainbow(PENDING_BANNER).yellow
 
-        pending_cops.each do |cop|
-          warn_pending_cop cop
-        end
+        pending_cops.each { |cop| warn_pending_cop cop }
 
         warn Rainbow('For more information: https://docs.rubocop.org/rubocop/versioning.html').yellow
       end
@@ -246,10 +241,9 @@ module RuboCop
       # stderr. Care is taken to use the standard OS exit code for a "file not
       # found" error.
       def read_file(absolute_path)
-        IO.read(absolute_path, encoding: Encoding::UTF_8)
+        File.read(absolute_path, encoding: Encoding::UTF_8)
       rescue Errno::ENOENT
-        raise ConfigNotFoundError,
-              "Configuration file not found: #{absolute_path}"
+        raise ConfigNotFoundError, "Configuration file not found: #{absolute_path}"
       end
 
       def yaml_safe_load(yaml_code, filename)

data/lib/rubocop/config_loader_resolver.rb

@@ -37,16 +37,30 @@ module RuboCop
                       inherit_mode: determine_inherit_mode(hash, k))
           end
           hash[k] = v
+          fix_include_paths(base_config.loaded_path, hash, path, k, v) if v.key?('Include')
         end
       end
     end
 
+    # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the
+    # base configuration are relative to the directory where the base configuration file is. For the
+    # derived configuration, we need to make those paths relative to where the derived configuration
+    # file is.
+    def fix_include_paths(base_config_path, hash, path, key, value)
+      return unless File.basename(base_config_path).start_with?('.rubocop')
+
+      base_dir = File.dirname(base_config_path)
+      derived_dir = File.dirname(path)
+      hash[key]['Include'] = value['Include'].map do |include_path|
+        PathUtil.relative_path(File.join(base_dir, include_path), derived_dir)
+      end
+    end
+
     def resolve_inheritance_from_gems(hash)
       gems = hash.delete('inherit_gem')
       (gems || {}).each_pair do |gem_name, config_path|
         if gem_name == 'rubocop'
-          raise ArgumentError,
-                "can't inherit configuration from the rubocop gem"
+          raise ArgumentError, "can't inherit configuration from the rubocop gem"
         end
 
         hash['inherit_from'] = Array(hash['inherit_from'])
@@ -77,8 +91,7 @@ module RuboCop
       config = handle_disabled_by_default(config, default_configuration) if disabled_by_default
       override_enabled_for_disabled_departments(default_configuration, config)
 
-      opts = { inherit_mode: config['inherit_mode'] || {},
-               unset_nil: unset_nil }
+      opts = { inherit_mode: config['inherit_mode'] || {}, unset_nil: unset_nil }
       Config.new(merge(default_configuration, config, **opts), config_file)
     end
 
@@ -112,8 +125,7 @@ module RuboCop
         next unless key =~ %r{(.*)/.*}
 
         department = Regexp.last_match(1)
-        next unless disabled?(derived_hash, department) ||
-                    disabled?(base_hash, department)
+        next unless disabled?(derived_hash, department) || disabled?(base_hash, department)
 
         # The `override_department` setting for the `Enabled` parameter is an
         # internal setting that's not documented in the manual. It will cause a
@@ -155,13 +167,10 @@ module RuboCop
     end
 
     def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts)
-      return unless duplicate_setting?(base_hash, derived_hash,
-                                       key, opts[:inherited_file])
+      return unless duplicate_setting?(base_hash, derived_hash, key, opts[:inherited_file])
 
-      inherit_mode = opts[:inherit_mode]['merge'] ||
-                     opts[:inherit_mode]['override']
-      return if base_hash[key].is_a?(Array) &&
-                inherit_mode && inherit_mode.include?(key)
+      inherit_mode = opts[:inherit_mode]['merge'] || opts[:inherit_mode]['override']
+      return if base_hash[key].is_a?(Array) && inherit_mode && inherit_mode.include?(key)
 
       puts "#{PathUtil.smart_path(opts[:file])}: " \
            "#{opts[:cop_name]}:#{key} overrides " \
@@ -251,8 +260,7 @@ module RuboCop
 
       File.join(gem_path, relative_config_path)
     rescue Gem::LoadError => e
-      raise Gem::LoadError,
-            "Unable to find gem #{gem_name}; is the gem installed? #{e}"
+      raise Gem::LoadError, "Unable to find gem #{gem_name}; is the gem installed? #{e}"
     end
   end
 end