rubocop 0.87.1 → 0.89.1

data/lib/rubocop/cops_documentation_generator.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+# Class for generating documentation of all cops departments
+class CopsDocumentationGenerator # rubocop:disable Metrics/ClassLength
+  # This class will only generate documentation for cops that belong to one of
+  # the departments given in the `departments` array. E.g. if we only wanted
+  # documentation for Lint cops:
+  #
+  #   CopsDocumentationGenerator.new(departments: ['Lint']).call
+  #
+  def initialize(departments: [])
+    @departments = departments.map(&:to_sym).sort!
+    @cops = RuboCop::Cop::Registry.global
+    @config = RuboCop::ConfigLoader.default_configuration
+  end
+
+  def call
+    YARD::Registry.load!
+    departments.each do |department|
+      print_cops_of_department(department)
+    end
+
+    print_table_of_contents
+  ensure
+    RuboCop::ConfigLoader.default_configuration = nil
+  end
+
+  private
+
+  attr_reader :departments, :cops, :config
+
+  def cops_of_department(department)
+    cops.with_department(department).sort!
+  end
+
+  def cops_body(cop, description, examples_objects, pars)
+    content = h2(cop.cop_name)
+    content << required_ruby_version(cop)
+    content << properties(cop)
+    content << "#{description}\n"
+    content << examples(examples_objects) if examples_objects.count.positive?
+    content << configurations(pars)
+    content << references(cop)
+    content
+  end
+
+  def examples(examples_object)
+    examples_object.each_with_object(h3('Examples').dup) do |example, content|
+      content << "\n" unless content.end_with?("\n\n")
+      content << h4(example.name) unless example.name == ''
+      content << code_example(example)
+    end
+  end
+
+  def required_ruby_version(cop)
+    return '' unless cop.respond_to?(:required_minimum_ruby_version)
+
+    "NOTE: Required Ruby version: #{cop.required_minimum_ruby_version}\n\n"
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  def properties(cop)
+    header = [
+      'Enabled by default', 'Safe', 'Supports autocorrection', 'VersionAdded',
+      'VersionChanged'
+    ]
+    autocorrect = if cop.support_autocorrect?
+                    "Yes#{' (Unsafe)' unless cop.new(config).safe_autocorrect?}"
+                  else
+                    'No'
+                  end
+    cop_config = config.for_cop(cop)
+    content = [[
+      cop_status(cop_config.fetch('Enabled')),
+      cop_config.fetch('Safe', true) ? 'Yes' : 'No',
+      autocorrect,
+      cop_config.fetch('VersionAdded', '-'),
+      cop_config.fetch('VersionChanged', '-')
+    ]]
+    "#{to_table(header, content)}\n"
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  def h2(title)
+    content = +"\n"
+    content << "== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def h3(title)
+    content = +"\n"
+    content << "=== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def h4(title)
+    content = +"==== #{title}\n"
+    content << "\n"
+    content
+  end
+
+  def code_example(ruby_code)
+    content = +"[source,ruby]\n----\n"
+    content << ruby_code.text.gsub('@good', '# good')
+                        .gsub('@bad', '# bad').strip
+    content << "\n----\n"
+    content
+  end
+
+  def configurations(pars)
+    return '' if pars.empty?
+
+    header = ['Name', 'Default value', 'Configurable values']
+    configs = pars
+              .each_key
+              .reject { |key| key.start_with?('Supported') }
+              .reject { |key| key.start_with?('AllowMultipleStyles') }
+    content = configs.map do |name|
+      configurable = configurable_values(pars, name)
+      default = format_table_value(pars[name])
+      [name, default, configurable]
+    end
+
+    h3('Configurable attributes') + to_table(header, content)
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+  def configurable_values(pars, name)
+    case name
+    when /^Enforced/
+      supported_style_name = RuboCop::Cop::Util.to_supported_styles(name)
+      format_table_value(pars[supported_style_name])
+    when 'IndentationWidth'
+      'Integer'
+    when 'Database'
+      format_table_value(pars['SupportedDatabases'])
+    else
+      case pars[name]
+      when String
+        'String'
+      when Integer
+        'Integer'
+      when Float
+        'Float'
+      when true, false
+        'Boolean'
+      when Array
+        'Array'
+      else
+        ''
+      end
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity,Metrics/MethodLength
+
+  def to_table(header, content)
+    table = [
+      '|===',
+      "| #{header.join(' | ')}\n\n"
+    ].join("\n")
+    marked_contents = content.map do |plain_content|
+      plain_content.map { |c| "| #{c}" }.join("\n")
+    end
+    table << marked_contents.join("\n\n")
+    table << "\n|===\n"
+  end
+
+  def format_table_value(val)
+    value =
+      case val
+      when Array
+        if val.empty?
+          '`[]`'
+        else
+          val.map { |config| format_table_value(config) }.join(', ')
+        end
+      else
+        wrap_backtick(val.nil? ? '<none>' : val)
+      end
+    value.gsub("#{Dir.pwd}/", '').rstrip
+  end
+
+  def wrap_backtick(value)
+    if value.is_a?(String)
+      # Use `+` to prevent text like `**/*.gemspec` from being bold.
+      value.start_with?('*') ? "`+#{value}+`" : "`#{value}`"
+    else
+      "`#{value}`"
+    end
+  end
+
+  def references(cop)
+    cop_config = config.for_cop(cop)
+    urls = RuboCop::Cop::MessageAnnotator.new(
+      config, cop.name, cop_config, {}
+    ).urls
+    return '' if urls.empty?
+
+    content = h3('References')
+    content << urls.map { |url| "* #{url}" }.join("\n")
+    content << "\n"
+    content
+  end
+
+  def print_cops_of_department(department)
+    selected_cops = cops_of_department(department)
+    content = +"= #{department}\n"
+    selected_cops.each do |cop|
+      content << print_cop_with_doc(cop)
+    end
+    file_name = "#{Dir.pwd}/docs/modules/ROOT/pages/cops_#{department.downcase}.adoc"
+    File.open(file_name, 'w') do |file|
+      puts "* generated #{file_name}"
+      file.write("#{content.strip}\n")
+    end
+  end
+
+  def print_cop_with_doc(cop)
+    cop_config = config.for_cop(cop)
+    non_display_keys = %w[
+      Description Enabled StyleGuide Reference Safe SafeAutoCorrect VersionAdded
+      VersionChanged
+    ]
+    pars = cop_config.reject { |k| non_display_keys.include? k }
+    description = 'No documentation'
+    examples_object = []
+    cop_code(cop) do |code_object|
+      description = code_object.docstring unless code_object.docstring.blank?
+      examples_object = code_object.tags('example')
+    end
+    cops_body(cop, description, examples_object, pars)
+  end
+
+  def cop_code(cop)
+    YARD::Registry.all(:class).detect do |code_object|
+      next unless RuboCop::Cop::Badge.for(code_object.to_s) == cop.badge
+
+      yield code_object
+    end
+  end
+
+  def table_of_content_for_department(department)
+    type_title = department[0].upcase + department[1..-1]
+    filename = "cops_#{department.downcase}.adoc"
+    content = +"=== Department xref:#{filename}[#{type_title}]\n\n"
+    cops_of_department(department).each do |cop|
+      anchor = cop.cop_name.sub('/', '').downcase
+      content << "* xref:#{filename}##{anchor}[#{cop.cop_name}]\n"
+    end
+
+    content
+  end
+
+  def print_table_of_contents
+    path = "#{Dir.pwd}/docs/modules/ROOT/pages/cops.adoc"
+    original = File.read(path)
+    content = +"// START_COP_LIST\n\n"
+
+    content << table_contents
+
+    content << "\n// END_COP_LIST"
+
+    content = original.sub(
+      %r{// START_COP_LIST.+// END_COP_LIST}m, content
+    )
+    File.write(path, content)
+  end
+
+  def table_contents
+    departments
+      .map { |department| table_of_content_for_department(department) }
+      .join("\n")
+  end
+
+  def cop_status(status)
+    return 'Disabled' unless status
+
+    status == 'pending' ? 'Pending' : 'Enabled'
+  end
+end

data/lib/rubocop/error.rb

@@ -12,6 +12,7 @@ module RuboCop
   # A wrapper to display errored location of analyzed file.
   class ErrorWithAnalyzedFileLocation < Error
     def initialize(cause:, node:, cop:)
+      super()
       @cause = cause
       @cop = cop
       @location = node.is_a?(RuboCop::AST::Node) ? node.loc : node

data/lib/rubocop/file_finder.rb

@@ -9,33 +9,33 @@ module RuboCop
       @root_level = level
     end
 
-    def self.root_level?(path)
-      @root_level == path.to_s
+    def self.root_level?(path, stop_dir)
+      (@root_level || stop_dir) == path.to_s
     end
 
-    def find_file_upwards(filename, start_dir)
-      traverse_files_upwards(filename, start_dir) do |file|
+    def find_file_upwards(filename, start_dir, stop_dir = nil)
+      traverse_files_upwards(filename, start_dir, stop_dir) do |file|
         # minimize iteration for performance
         return file if file
       end
     end
 
-    def find_files_upwards(filename, start_dir)
-      files = []
-      traverse_files_upwards(filename, start_dir) do |file|
-        files << file
+    def find_last_file_upwards(filename, start_dir, stop_dir = nil)
+      last_file = nil
+      traverse_files_upwards(filename, start_dir, stop_dir) do |file|
+        last_file = file
       end
-      files
+      last_file
     end
 
     private
 
-    def traverse_files_upwards(filename, start_dir)
+    def traverse_files_upwards(filename, start_dir, stop_dir)
       Pathname.new(start_dir).expand_path.ascend do |dir|
-        break if FileFinder.root_level?(dir)
-
         file = dir + filename
         yield(file.to_s) if file.exist?
+
+        break if FileFinder.root_level?(dir, stop_dir)
       end
     end
   end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -114,7 +114,7 @@ module RuboCop
       def output_cop_comments(output_buffer, cfg, cop_name, offense_count)
         output_buffer.puts "# Offense count: #{offense_count}" if @show_offense_counts
 
-        cop_class = Cop::Cop.registry.find_by_cop_name(cop_name)
+        cop_class = Cop::Registry.global.find_by_cop_name(cop_name)
         output_buffer.puts '# Cop supports --auto-correct.' if cop_class&.support_autocorrect?
 
         default_cfg = default_config(cop_name)

data/lib/rubocop/formatter/formatter_set.rb

@@ -35,6 +35,7 @@ module RuboCop
       end
 
       def initialize(options = {})
+        super()
         @options = options # CLI options
       end
 

data/lib/rubocop/formatter/junit_formatter.rb

@@ -34,7 +34,7 @@ module RuboCop
         # https://github.com/mikian/rubocop-junit-formatter/blob/v0.1.4/lib/rubocop/formatter/junit_formatter.rb#L9
         #
         # In the future, it would be preferable to return only enabled cops.
-        Cop::Cop.all.each do |cop|
+        Cop::Registry.all.each do |cop|
           target_offenses = offenses_for_cop(offenses, cop)
 
           next unless relevant_for_output?(options, target_offenses)

data/lib/rubocop/options.rb

@@ -94,7 +94,7 @@ module RuboCop
             ['']
           else
             list.split(',').map do |c|
-              Cop::Cop.qualified_cop_name(c, "--#{option} option")
+              Cop::Registry.qualified_cop_name(c, "--#{option} option")
             end
           end
       end
@@ -239,8 +239,8 @@ module RuboCop
       def validate_cop_list(names)
         return unless names
 
-        cop_names = Cop::Cop.registry.names
-        departments = Cop::Cop.registry.departments.map(&:to_s)
+        cop_names = Cop::Registry.global.names
+        departments = Cop::Registry.global.departments.map(&:to_s)
 
         names.each do |name|
           next if cop_names.include?(name)

data/lib/rubocop/path_util.rb

@@ -5,7 +5,7 @@ module RuboCop
   module PathUtil
     module_function
 
-    def relative_path(path, base_dir = PathUtil.pwd)
+    def relative_path(path, base_dir = Dir.pwd)
       # Optimization for the common case where path begins with the base
       # dir. Just cut off the first part.
       if path.start_with?(base_dir)
@@ -24,7 +24,7 @@ module RuboCop
 
     def smart_path(path)
       # Ideally, we calculate this relative to the project root.
-      base_dir = PathUtil.pwd
+      base_dir = Dir.pwd
 
       if path.start_with? base_dir
         relative_path(path, base_dir)
@@ -54,26 +54,26 @@ module RuboCop
       %r{\A([A-Z]:)?/}i.match?(path)
     end
 
-    def self.pwd
-      @pwd ||= Dir.pwd
+    def hidden_file_in_not_hidden_dir?(pattern, path)
+      hidden_file?(path) &&
+        File.fnmatch?(
+          pattern, path,
+          File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
+        ) &&
+        !hidden_dir?(path)
     end
 
-    def self.reset_pwd
-      @pwd = nil
+    def hidden_file?(path)
+      maybe_hidden_file?(path) && File.basename(path).start_with?('.')
     end
 
-    def self.chdir(dir, &block)
-      reset_pwd
-      Dir.chdir(dir, &block)
-    ensure
-      reset_pwd
-    end
+    # Loose check to reduce memory allocations
+    def maybe_hidden_file?(path)
+      separator_index = path.rindex(File::SEPARATOR)
+      return false unless separator_index
 
-    def hidden_file_in_not_hidden_dir?(pattern, path)
-      File.fnmatch?(
-        pattern, path,
-        File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH
-      ) && File.basename(path).start_with?('.') && !hidden_dir?(path)
+      dot_index = path.index('.', separator_index + 1)
+      dot_index == separator_index + 1
     end
 
     def hidden_dir?(path)

data/lib/rubocop/rake_task.rb

@@ -15,6 +15,7 @@ module RuboCop
     attr_accessor :name, :verbose, :fail_on_error, :patterns, :formatters, :requires, :options
 
     def initialize(name = :rubocop, *args, &task_block)
+      super()
       setup_ivars(name)
 
       desc 'Run RuboCop' unless ::Rake.application.last_description