rubocop 0.78.0

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Shows the given cops, or all cops by default, and their configurations
+      # for the current directory.
+      class ShowCops < Base
+        self.command_name = :show_cops
+
+        def run
+          print_available_cops
+        end
+
+        private
+
+        def print_available_cops
+          # Load the configs so the require()s are done for custom cops
+          @config_store.for(Dir.pwd)
+          registry = Cop::Cop.registry
+          show_all = @options[:show_cops].empty?
+
+          if show_all
+            puts "# Available cops (#{registry.length}) " \
+                 "+ config for #{Dir.pwd}: "
+          end
+
+          registry.departments.sort!.each do |department|
+            print_cops_of_department(registry, department, show_all)
+          end
+        end
+
+        def print_cops_of_department(registry, department, show_all)
+          selected_cops = if show_all
+                            cops_of_department(registry, department)
+                          else
+                            selected_cops_of_department(registry, department)
+                          end
+
+          if show_all
+            puts "# Department '#{department}' (#{selected_cops.length}):"
+          end
+
+          print_cop_details(selected_cops)
+        end
+
+        def print_cop_details(cops)
+          cops.each do |cop|
+            puts '# Supports --auto-correct' if cop.new.support_autocorrect?
+            puts "#{cop.cop_name}:"
+            puts config_lines(cop)
+            puts
+          end
+        end
+
+        def selected_cops_of_department(cops, department)
+          cops_of_department(cops, department).select do |cop|
+            @options[:show_cops].include?(cop.cop_name)
+          end
+        end
+
+        def cops_of_department(cops, department)
+          cops.with_department(department).sort!
+        end
+
+        def config_lines(cop)
+          cnf = @config_store.for(Dir.pwd).for_cop(cop)
+          cnf.to_yaml.lines.to_a.drop(1).map { |line| '  ' + line }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    module Command
+      # Display version.
+      class Version < Base
+        self.command_name = :version
+
+        def run
+          puts RuboCop::Version.version(false) if @options[:version]
+          puts RuboCop::Version.version(true) if @options[:verbose_version]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cli/environment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  class CLI
+    # Execution environment for a CLI command.
+    class Environment
+      attr_reader :options, :config_store, :paths
+
+      def initialize(options, config_store, paths)
+        @options = options
+        @config_store = config_store
+        @paths = paths
+      end
+
+      # Run a command in this environment.
+      def run(name)
+        Command.run(self, name)
+      end
+    end
+  end
+end

data/lib/rubocop/comment_config.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+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
+    REDUNDANT_DISABLE = 'Lint/RedundantCopDisableDirective'
+
+    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'
+    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}"
+    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})"
+
+    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
+
+    def initialize(processed_source)
+      @processed_source = processed_source
+    end
+
+    def cop_enabled_at_line?(cop, line_number)
+      cop = cop.cop_name if cop.respond_to?(:cop_name)
+      disabled_line_ranges = cop_disabled_line_ranges[cop]
+      return true unless disabled_line_ranges
+
+      disabled_line_ranges.none? { |range| range.include?(line_number) }
+    end
+
+    def cop_disabled_line_ranges
+      @cop_disabled_line_ranges ||= analyze
+    end
+
+    def extra_enabled_comments
+      extra_enabled_comments_with_names([], {})
+    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)
+
+        if !disabled && enable_all?(comment)
+          handle_enable_all(names, extras, comment)
+        else
+          handle_switch(cop_names, names, disabled, extras, comment)
+        end
+      end
+
+      extras
+    end
+
+    def analyze
+      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)
+      end
+
+      analyses.each_with_object({}) do |element, hash|
+        cop_name, analysis = *element
+        hash[cop_name] = cop_line_ranges(analysis)
+      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)
+      else
+        analyze_rest(analysis, line)
+      end
+    end
+
+    def analyze_single_line(analysis, line, disabled)
+      return analysis unless disabled
+
+      CopAnalysis.new(analysis.line_ranges + [(line..line)],
+                      analysis.start_line_number)
+    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
+
+      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
+
+      CopAnalysis.new(analysis.line_ranges, nil)
+    end
+
+    def cop_line_ranges(analysis)
+      return analysis.line_ranges unless analysis.start_line_number
+
+      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)
+
+        cop_names.each do |cop_name|
+          yield qualified_cop_name(cop_name), disabled, comment_line_number,
+                single_line
+        end
+      end
+    end
+
+    def each_directive
+      return if processed_source.comments.nil?
+
+      processed_source.each_comment do |comment|
+        directive = directive_parts(comment)
+        next unless directive
+
+        yield comment, *directive
+      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::Cop.qualified_cop_name(cop_name.strip, processed_source.file_path)
+    end
+
+    def all_cop_names
+      @all_cop_names ||= Cop::Cop.registry.names - [REDUNDANT_DISABLE]
+    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
+    end
+
+    def non_comment_token_line_numbers
+      @non_comment_token_line_numbers ||= begin
+        non_comment_tokens = processed_source.tokens.reject(&:comment?)
+        non_comment_tokens.map(&:line).uniq
+      end
+    end
+
+    def enable_all?(comment)
+      _, cops = comment.text.match(COMMENT_DIRECTIVE_REGEXP).captures
+      cops == 'all'
+    end
+
+    def handle_enable_all(names, extras, comment)
+      enabled_cops = 0
+      names.each do |name, counter|
+        next unless counter.positive?
+
+        names[name] -= 1
+        enabled_cops += 1
+      end
+
+      extras << [comment, 'all'] if enabled_cops.zero?
+    end
+
+    def handle_switch(cop_names, names, disabled, extras, comment)
+      cop_names.each do |name|
+        names[name] ||= 0
+        if disabled
+          names[name] += 1
+        elsif (names[name]).positive?
+          names[name] -= 1
+        else
+          extras << [comment, name]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/config.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+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.
+  class Config
+    include PathUtil
+    include FileFinder
+    extend Forwardable
+
+    DEFAULT_RAILS_VERSION = 5.0
+    attr_reader :loaded_path
+
+    def initialize(hash = {}, loaded_path = nil)
+      @loaded_path = loaded_path
+      @for_cop = Hash.new do |h, cop|
+        qualified_cop_name = Cop::Cop.qualified_cop_name(cop, loaded_path)
+        cop_options = self[qualified_cop_name] || {}
+        cop_options['Enabled'] = enable_cop?(qualified_cop_name, cop_options)
+        h[cop] = cop_options
+      end
+      @hash = hash
+      @validator = ConfigValidator.new(self)
+    end
+
+    def self.create(hash, path)
+      new(hash, path).check
+    end
+
+    def check
+      deprecation_check do |deprecation_message|
+        warn("#{loaded_path} - #{deprecation_message}")
+      end
+      @validator.validate
+      make_excludes_absolute
+      self
+    end
+
+    def_delegators :@hash, :[], :[]=, :delete, :each, :key?, :keys, :each_key,
+                   :map, :merge, :to_h, :to_hash
+    def_delegators :@validator, :validate, :target_ruby_version
+
+    def to_s
+      @to_s ||= @hash.to_s
+    end
+
+    def signature
+      @signature ||= Digest::SHA1.hexdigest(to_s)
+    end
+
+    # 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'))
+      File.expand_path(loaded_path).start_with?(base_config_path)
+    end
+
+    def make_excludes_absolute
+      each_key do |key|
+        @validator.validate_section_presence(key)
+        next unless self[key]['Exclude']
+
+        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))
+          else
+            exclude_elem
+          end
+        end
+      end
+    end
+
+    def add_excludes_from_higher_level(highest_config)
+      return unless highest_config.for_all_cops['Exclude']
+
+      excludes = for_all_cops['Exclude'] ||= []
+      highest_config.for_all_cops['Exclude'].each do |path|
+        unless path.is_a?(Regexp) || absolute?(path)
+          path = File.join(File.dirname(highest_config.loaded_path), path)
+        end
+        excludes << path unless excludes.include?(path)
+      end
+    end
+
+    def deprecation_check
+      %w[Exclude Include].each do |key|
+        plural = "#{key}s"
+        next unless for_all_cops[plural]
+
+        for_all_cops[key] = for_all_cops[plural] # Stay backwards compatible.
+        for_all_cops.delete(plural)
+        yield "AllCops/#{plural} was renamed to AllCops/#{key}"
+      end
+    end
+
+    def for_cop(cop)
+      @for_cop[cop.respond_to?(:cop_name) ? cop.cop_name : cop]
+    end
+
+    def for_department(department_name)
+      @for_cop[department_name]
+    end
+
+    def for_all_cops
+      @for_all_cops ||= self['AllCops'] || {}
+    end
+
+    def file_to_include?(file)
+      relative_file_path = path_relative_to_config(file)
+
+      # 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?('..')
+      return false if is_hidden && !possibly_include_hidden?
+
+      absolute_file_path = File.expand_path(file)
+
+      patterns_to_include.any? do |pattern|
+        if block_given?
+          yield pattern, relative_file_path, absolute_file_path
+        else
+          match_path?(pattern, relative_file_path) ||
+            match_path?(pattern, absolute_file_path)
+        end
+      end
+    end
+
+    def allowed_camel_case_file?(file)
+      # Gemspecs are allowed to have dashes because that fits with bundler best
+      # practices in the case when the gem is nested under a namespace (e.g.,
+      # `bundler-console` conveys `Bundler::Console`).
+      return true if File.extname(file) == '.gemspec'
+
+      file_to_include?(file) do |pattern, relative_path, absolute_path|
+        pattern.to_s =~ /[A-Z]/ &&
+          (match_path?(pattern, relative_path) ||
+           match_path?(pattern, absolute_path))
+      end
+    end
+
+    # Returns true if there's a chance that an Include pattern matches hidden
+    # files, false if that's definitely not possible.
+    def possibly_include_hidden?
+      return @possibly_include_hidden if defined?(@possibly_include_hidden)
+
+      @possibly_include_hidden = patterns_to_include.any? do |s|
+        s.is_a?(Regexp) || s.start_with?('.') || s.include?('/.')
+      end
+    end
+
+    def file_to_exclude?(file)
+      file = File.expand_path(file)
+      patterns_to_exclude.any? do |pattern|
+        match_path?(pattern, file)
+      end
+    end
+
+    def patterns_to_include
+      for_all_cops['Include'] || []
+    end
+
+    def patterns_to_exclude
+      for_all_cops['Exclude'] || []
+    end
+
+    def path_relative_to_config(path)
+      relative_path(path, base_dir_for_path_parameters)
+    end
+
+    # Paths specified in configuration files starting with .rubocop are
+    # relative to the directory where that file is. Paths in other config files
+    # are relative to the current directory. This is so that paths in
+    # config/default.yml, for example, are not relative to RuboCop's config
+    # directory since that wouldn't work.
+    def base_dir_for_path_parameters
+      @base_dir_for_path_parameters ||=
+        if File.basename(loaded_path).start_with?('.rubocop') &&
+           loaded_path != File.join(Dir.home, ConfigLoader::DOTFILE)
+          File.expand_path(File.dirname(loaded_path))
+        else
+          Dir.pwd
+        end
+    end
+
+    def target_rails_version
+      @target_rails_version ||=
+        if for_all_cops['TargetRailsVersion']
+          for_all_cops['TargetRailsVersion'].to_f
+        elsif target_rails_version_from_bundler_lock_file
+          target_rails_version_from_bundler_lock_file
+        else
+          DEFAULT_RAILS_VERSION
+        end
+    end
+
+    def smart_loaded_path
+      PathUtil.smart_path(@loaded_path)
+    end
+
+    def bundler_lock_file_path
+      return nil unless loaded_path
+
+      base_path = base_dir_for_path_parameters
+      ['gems.locked', 'Gemfile.lock'].each do |file_name|
+        path = find_file_upwards(file_name, base_path)
+        return path if path
+      end
+      nil
+    end
+
+    private
+
+    def target_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
+      lock_file_path = bundler_lock_file_path
+      return nil unless lock_file_path
+
+      File.foreach(lock_file_path) do |line|
+        # If rails is in Gemfile.lock or gems.lock, there should be a line like:
+        #         rails (X.X.X)
+        result = line.match(/^\s+rails\s+\((\d+\.\d+)/)
+        return result.captures.first.to_f if result
+      end
+    end
+
+    def enable_cop?(qualified_cop_name, cop_options)
+      cop_department, cop_name = qualified_cop_name.split('/')
+      department = cop_name.nil?
+
+      unless department
+        department_options = self[cop_department]
+        if department_options && department_options['Enabled'] == false
+          return false
+        end
+      end
+
+      cop_options.fetch('Enabled') { !for_all_cops['DisabledByDefault'] }
+    end
+  end
+end