rdoc 7.2.0 → 8.1.0

data/lib/rdoc/stats.rb

@@ -1,461 +1,486 @@
 # frozen_string_literal: true
-##
-# RDoc statistics collector which prints a summary and report of a project's
-# documentation totals.
-
-class RDoc::Stats
-
-  include RDoc::Text
-
+module RDoc
   ##
-  # Output level for the coverage report
+  # RDoc statistics collector which prints a summary and report of a project's
+  # documentation totals.
 
-  attr_reader :coverage_level
+  class Stats
 
-  ##
-  # Count of files parsed during parsing
+    include Text
 
-  attr_reader :files_so_far
+    ##
+    # Display order for item types in the coverage report
 
-  ##
-  # Total number of files found
+    TYPE_ORDER = %w[Class Module Constant Attribute Method].freeze
 
-  attr_reader :num_files
+    ##
+    # Message displayed when all items are documented
 
-  ##
-  # Creates a new Stats that will have +num_files+.  +verbosity+ defaults to 1
-  # which will create an RDoc::Stats::Normal outputter.
-
-  def initialize(store, num_files, verbosity = 1)
-    @num_files = num_files
-    @store     = store
-
-    @coverage_level   = 0
-    @doc_items        = nil
-    @files_so_far     = 0
-    @fully_documented = false
-    @num_params       = 0
-    @percent_doc      = nil
-    @start            = Time.now
-    @undoc_params     = 0
-
-    @display = case verbosity
-               when 0 then Quiet.new   num_files
-               when 1 then Normal.new  num_files
-               else        Verbose.new num_files
-               end
-  end
+    GREAT_JOB_MESSAGE = <<~MSG
+    100% documentation!
+    Great Job!
+  MSG
 
-  ##
-  # Records the parsing of an alias +as+.
-
-  def add_alias(as)
-    @display.print_alias as
-  end
+    ##
+    # Output level for the coverage report
 
-  ##
-  # Records the parsing of an attribute +attribute+
+    attr_reader :coverage_level
 
-  def add_attribute(attribute)
-    @display.print_attribute attribute
-  end
+    ##
+    # Count of files parsed during parsing
 
-  ##
-  # Records the parsing of a class +klass+
+    attr_reader :files_so_far
 
-  def add_class(klass)
-    @display.print_class klass
-  end
+    ##
+    # Total number of files found
 
-  ##
-  # Records the parsing of +constant+
+    attr_reader :num_files
 
-  def add_constant(constant)
-    @display.print_constant constant
-  end
+    ##
+    # Creates a new Stats that will have +num_files+.  +verbosity+ defaults to 1
+    # which will create an RDoc::Stats::Normal outputter.
 
-  ##
-  # Records the parsing of +file+
+    def initialize(store, num_files, verbosity = 1)
+      @num_files = num_files
+      @store     = store
 
-  def add_file(file)
-    @files_so_far += 1
-    @display.print_file @files_so_far, file
-  end
+      @coverage_level   = 0
+      @doc_items        = nil
+      @files_so_far     = 0
+      @fully_documented = false
+      @num_params       = 0
+      @percent_doc      = nil
+      @start            = Time.now
+      @undoc_params     = 0
 
-  ##
-  # Records the parsing of +method+
+      self.verbosity = verbosity
+    end
 
-  def add_method(method)
-    @display.print_method method
-  end
+    ##
+    # Sets the verbosity level, rebuilding the display outputter.
 
-  ##
-  # Records the parsing of a module +mod+
+    def verbosity=(verbosity)
+      @display = case verbosity
+                 when 0 then Quiet.new   @num_files
+                 when 1 then Normal.new  @num_files
+                 else        Verbose.new @num_files
+                 end
+    end
 
-  def add_module(mod)
-    @display.print_module mod
-  end
+    ##
+    # Records the parsing of an alias +as+.
 
-  ##
-  # Call this to mark the beginning of parsing for display purposes
+    def add_alias(as)
+      @display.print_alias as
+    end
 
-  def begin_adding
-    @display.begin_adding
-  end
+    ##
+    # Records the parsing of an attribute +attribute+
 
-  ##
-  # Calculates documentation totals and percentages for classes, modules,
-  # constants, attributes and methods.
+    def add_attribute(attribute)
+      @display.print_attribute attribute
+    end
 
-  def calculate
-    return if @doc_items
+    ##
+    # Records the parsing of a class +klass+
 
-    ucm = @store.unique_classes_and_modules
+    def add_class(klass)
+      @display.print_class klass
+    end
 
-    classes = @store.unique_classes.reject { |cm| cm.full_name == 'Object' }
+    ##
+    # Records the parsing of +constant+
 
-    constants = []
-    ucm.each { |cm| constants.concat cm.constants }
+    def add_constant(constant)
+      @display.print_constant constant
+    end
 
-    methods = []
-    ucm.each { |cm| methods.concat cm.method_list }
+    ##
+    # Records the parsing of +file+
 
-    attributes = []
-    ucm.each { |cm| attributes.concat cm.attributes }
+    def add_file(file)
+      @files_so_far += 1
+      @display.print_file @files_so_far, file
+    end
 
-    @num_attributes, @undoc_attributes = doc_stats attributes
-    @num_classes,    @undoc_classes    = doc_stats classes
-    @num_constants,  @undoc_constants  = doc_stats constants
-    @num_methods,    @undoc_methods    = doc_stats methods
-    @num_modules,    @undoc_modules    = doc_stats @store.unique_modules
+    ##
+    # Records the parsing of +method+
 
-    @num_items =
-      @num_attributes +
-      @num_classes +
-      @num_constants +
-      @num_methods +
-      @num_modules +
-      @num_params
+    def add_method(method)
+      @display.print_method method
+    end
 
-    @undoc_items =
-      @undoc_attributes +
-      @undoc_classes +
-      @undoc_constants +
-      @undoc_methods +
-      @undoc_modules +
-      @undoc_params
+    ##
+    # Records the parsing of a module +mod+
 
-    @doc_items = @num_items - @undoc_items
-  end
+    def add_module(mod)
+      @display.print_module mod
+    end
 
-  ##
-  # Sets coverage report level.  Accepted values are:
-  #
-  # false or nil:: No report
-  # 0:: Classes, modules, constants, attributes, methods
-  # 1:: Level 0 + method parameters
+    ##
+    # Call this to mark the beginning of parsing for display purposes
 
-  def coverage_level=(level)
-    level = -1 unless level
+    def begin_adding
+      @display.begin_adding
+    end
 
-    @coverage_level = level
-  end
+    ##
+    # Calculates documentation totals and percentages for classes, modules,
+    # constants, attributes and methods.
 
-  ##
-  # Returns the length and number of undocumented items in +collection+.
+    def calculate
+      return if @doc_items
 
-  def doc_stats(collection)
-    visible = collection.select { |item| item.display? }
-    [visible.length, visible.count { |item| not item.documented? }]
-  end
+      ucm = @store.unique_classes_and_modules
 
-  ##
-  # Call this to mark the end of parsing for display purposes
+      classes = @store.unique_classes.reject { |cm| cm.full_name == 'Object' }
 
-  def done_adding
-    @display.done_adding
-  end
+      constants = []
+      ucm.each { |cm| constants.concat cm.constants }
 
-  ##
-  # The documentation status of this project.  +true+ when 100%, +false+ when
-  # less than 100% and +nil+ when unknown.
-  #
-  # Set by calling #calculate
+      methods = []
+      ucm.each { |cm| methods.concat cm.method_list }
 
-  def fully_documented?
-    @fully_documented
-  end
+      attributes = []
+      ucm.each { |cm| attributes.concat cm.attributes }
 
-  ##
-  # A report that says you did a great job!
+      @num_attributes, @undoc_attributes = doc_stats attributes
+      @num_classes,    @undoc_classes    = doc_stats classes
+      @num_constants,  @undoc_constants  = doc_stats constants
+      @num_methods,    @undoc_methods    = doc_stats methods
+      @num_modules,    @undoc_modules    = doc_stats @store.unique_modules
 
-  def great_job
-    report = RDoc::Markup::Document.new
+      @num_items =
+        @num_attributes +
+        @num_classes +
+        @num_constants +
+        @num_methods +
+        @num_modules +
+        @num_params
 
-    report << RDoc::Markup::Paragraph.new('100% documentation!')
-    report << RDoc::Markup::Paragraph.new('Great Job!')
+      @undoc_items =
+        @undoc_attributes +
+        @undoc_classes +
+        @undoc_constants +
+        @undoc_methods +
+        @undoc_modules +
+        @undoc_params
 
-    report
-  end
+      @doc_items = @num_items - @undoc_items
+    end
 
-  ##
-  # Calculates the percentage of items documented.
+    ##
+    # Sets coverage report level.  Accepted values are:
+    #
+    # false or nil:: No report
+    # 0:: Classes, modules, constants, attributes, methods
+    # 1:: Level 0 + method parameters
 
-  def percent_doc
-    return @percent_doc if @percent_doc
+    def coverage_level=(level)
+      level = -1 unless level
 
-    @fully_documented = (@num_items - @doc_items) == 0
+      @coverage_level = level
+    end
 
-    @percent_doc = @doc_items.to_f / @num_items * 100 if @num_items.nonzero?
-    @percent_doc ||= 0
+    ##
+    # Returns the length and number of undocumented items in +collection+.
 
-    @percent_doc
-  end
+    def doc_stats(collection)
+      visible = collection.select { |item| item.display? }
+      [visible.length, visible.count { |item| not item.documented? }]
+    end
 
-  ##
-  # Returns a report on which items are not documented
+    ##
+    # Call this to mark the end of parsing for display purposes
 
-  def report
-    if @coverage_level > 0 then
-      extend RDoc::Text
+    def done_adding
+      @display.done_adding
     end
 
-    if @coverage_level.zero? then
-      calculate
+    ##
+    # The documentation status of this project.  +true+ when 100%, +false+ when
+    # less than 100% and +nil+ when unknown.
+    #
+    # Set by calling #calculate
 
-      return great_job if @num_items == @doc_items
+    def fully_documented?
+      @fully_documented
     end
 
-    ucm = @store.unique_classes_and_modules
+    ##
+    # Calculates the percentage of items documented.
+
+    def percent_doc
+      return @percent_doc if @percent_doc
 
-    report = RDoc::Markup::Document.new
-    report << RDoc::Markup::Paragraph.new('The following items are not documented:')
-    report << RDoc::Markup::BlankLine.new
+      @fully_documented = (@num_items - @doc_items) == 0
 
-    ucm.sort.each do |cm|
-      body = report_class_module(cm) {
-        [
-          report_constants(cm),
-          report_attributes(cm),
-          report_methods(cm),
-        ].compact
-      }
+      @percent_doc = @doc_items.to_f / @num_items * 100 if @num_items.nonzero?
+      @percent_doc ||= 0
 
-      report << body if body
+      @percent_doc
     end
 
-    if @coverage_level > 0 then
-      calculate
+    ##
+    # Returns a report on which items are not documented
 
-      return great_job if @num_items == @doc_items
-    end
+    def report
+      if @coverage_level > 0
+        extend Text
+      end
 
-    report
-  end
+      if @coverage_level.zero?
+        calculate
 
-  ##
-  # Returns a report on undocumented attributes in ClassModule +cm+
+        return GREAT_JOB_MESSAGE if @num_items == @doc_items
+      end
 
-  def report_attributes(cm)
-    return if cm.attributes.empty?
+      items, empty_classes = collect_undocumented_items
 
-    report = []
+      if @coverage_level > 0
+        calculate
 
-    cm.attributes.each do |attr|
-      next if attr.documented?
-      line = attr.line ? ":#{attr.line}" : nil
-      report << "  #{attr.definition} :#{attr.name} # in file #{attr.file.full_name}#{line}\n"
-      report << "\n"
-    end
+        return GREAT_JOB_MESSAGE if @num_items == @doc_items
+      end
 
-    report
-  end
+      report = +""
+      report << "The following items are not documented:\n\n"
 
-  ##
-  # Returns a report on undocumented items in ClassModule +cm+
+      # Referenced-but-empty classes
+      empty_classes.each do |cm|
+        report << "#{cm.full_name} is referenced but empty.\n"
+        report << "It probably came from another project.  I'm sorry I'm holding it against you.\n\n"
+      end
 
-  def report_class_module(cm)
-    return if cm.fully_documented? and @coverage_level.zero?
-    return unless cm.display?
+      # Group items by file, then by type
+      by_file = items.group_by { |item| item[:file] }
 
-    report = RDoc::Markup::Document.new
+      by_file.sort_by { |file, _| file }.each do |file, file_items|
+        report << "#{file}:\n"
 
-    if cm.in_files.empty? then
-      report << RDoc::Markup::Paragraph.new("#{cm.definition} is referenced but empty.")
-      report << RDoc::Markup::Paragraph.new("It probably came from another project.  I'm sorry I'm holding it against you.")
+        by_type = file_items.group_by { |item| item[:type] }
 
-      return report
-    elsif cm.documented? then
-      documented = true
-      klass = RDoc::Markup::Verbatim.new("#{cm.definition} # is documented\n")
-    else
-      report << RDoc::Markup::Paragraph.new('In files:')
+        TYPE_ORDER.each do |type|
+          next unless by_type[type]
 
-      list = RDoc::Markup::List.new :BULLET
+          report << "  #{type}:\n"
 
-      cm.in_files.each do |file|
-        para = RDoc::Markup::Paragraph.new file.full_name
-        list << RDoc::Markup::ListItem.new(nil, para)
-      end
+          sorted = by_type[type].sort_by { |item| [item[:line] || 0, item[:name]] }
+          name_width = sorted.reduce(0) { |max, item| item[:line] && item[:name].length > max ? item[:name].length : max }
 
-      report << list
-      report << RDoc::Markup::BlankLine.new
+          sorted.each do |item|
+            if item[:line]
+              report << "    %-*s %s:%d\n" % [name_width, item[:name], item[:file], item[:line]]
+            else
+              report << "    #{item[:name]}\n"
+            end
+
+            if item[:undoc_params]
+              report << "      Undocumented params: #{item[:undoc_params].join(', ')}\n"
+            end
+          end
+        end
 
-      klass = RDoc::Markup::Verbatim.new("#{cm.definition}\n")
+        report << "\n"
+      end
+
+      report
     end
 
-    klass << "\n"
+    ##
+    # Collects all undocumented items across all classes and modules.
+    # Returns [items, empty_classes] where items is an Array of Hashes
+    # with keys :type, :name, :file, :line, and empty_classes is an
+    # Array of ClassModule objects that are referenced but have no files.
 
-    body = yield.flatten # HACK remove #flatten
+    def collect_undocumented_items
+      empty_classes = []
+      items = []
 
-    if body.empty? then
-      return if documented
+      @store.unique_classes_and_modules.each do |class_module|
+        next unless class_module.display?
 
-      klass.parts.pop
-    else
-      klass.parts.concat body
-    end
+        if class_module.in_files.empty?
+          empty_classes << class_module
+          next
+        end
 
-    klass << "end\n"
+        unless class_module.documented? || class_module.full_name == 'Object'
+          collect_undocumented_class_module(class_module, items)
+        end
 
-    report << klass
+        collect_undocumented_constants(class_module, items)
+        collect_undocumented_attributes(class_module, items)
+        collect_undocumented_methods(class_module, items)
+      end
 
-    report
-  end
+      [items, empty_classes]
+    end
 
-  ##
-  # Returns a report on undocumented constants in ClassModule +cm+
+    ##
+    # Collects undocumented classes or modules from +class_module+ into +items+.
+    # Reopened classes/modules are reported in every file they appear in.
+
+    def collect_undocumented_class_module(class_module, items)
+      class_module.in_files.map(&:full_name).uniq.each do |file|
+        items << {
+          type: class_module.type.capitalize,
+          name: class_module.full_name,
+          file: file,
+          line: nil,
+        }
+      end
+    end
 
-  def report_constants(cm)
-    return if cm.constants.empty?
+    ##
+    # Collects undocumented constants from +class_module+ into +items+.
 
-    report = []
+    def collect_undocumented_constants(class_module, items)
+      class_module.constants.each do |constant|
+        next unless constant.display?
+        next if constant.documented? || constant.is_alias_for
 
-    cm.constants.each do |constant|
-      # TODO constant aliases are listed in the summary but not reported
-      # figure out what to do here
-      next if constant.documented? || constant.is_alias_for
+        file = constant.file&.full_name
+        next unless file
 
-      line = constant.line ? ":#{constant.line}" : line
-      report << "  # in file #{constant.file.full_name}#{line}\n"
-      report << "  #{constant.name} = nil\n"
-      report << "\n"
+        items << {
+          type: "Constant",
+          name: constant.full_name,
+          file: file,
+          line: constant.line,
+        }
+      end
     end
 
-    report
-  end
+    ##
+    # Collects undocumented attributes from +class_module+ into +items+.
 
-  ##
-  # Returns a report on undocumented methods in ClassModule +cm+
+    def collect_undocumented_attributes(class_module, items)
+      class_module.attributes.each do |attr|
+        next unless attr.display?
+        next if attr.documented?
 
-  def report_methods(cm)
-    return if cm.method_list.empty?
+        file = attr.file&.full_name
+        next unless file
 
-    report = []
+        scope = attr.singleton ? "." : "#"
+        items << {
+          type: "Attribute",
+          name: "#{class_module.full_name}#{scope}#{attr.name}",
+          file: file,
+          line: attr.line,
+        }
+      end
+    end
 
-    cm.each_method do |method|
-      next if method.documented? and @coverage_level.zero?
+    ##
+    # Collects undocumented methods from +class_module+ into +items+.
+    # At coverage level > 0, also counts undocumented parameters.
 
-      if @coverage_level > 0 then
-        params, undoc = undoc_params method
+    def collect_undocumented_methods(class_module, items)
+      class_module.each_method do |method|
+        next unless method.display?
+        next if method.documented? && @coverage_level.zero?
 
-        @num_params += params
+        undoc_param_names = nil
 
-        unless undoc.empty? then
-          @undoc_params += undoc.length
+        if @coverage_level > 0
+          params, undoc = undoc_params method
+          @num_params += params
 
-          undoc = undoc.map do |param| "+#{param}+" end
-          param_report = "  # #{undoc.join ', '} is not documented\n"
+          unless undoc.empty?
+            @undoc_params += undoc.length
+            undoc_param_names = undoc
+          end
         end
+
+        next if method.documented? && !undoc_param_names
+
+        file = method.file&.full_name
+        next unless file
+
+        scope = method.singleton ? "." : "#"
+        item = {
+          type: "Method",
+          name: "#{class_module.full_name}#{scope}#{method.name}",
+          file: file,
+          line: method.line,
+        }
+        item[:undoc_params] = undoc_param_names if undoc_param_names
+
+        items << item
       end
+    end
 
-      next if method.documented? and not param_report
+    ##
+    # Returns a summary of the collected statistics.
 
-      line = method.line ? ":#{method.line}" : nil
-      scope = method.singleton ? 'self.' : nil
+    def summary
+      calculate
+
+      num_width = [@num_files, @num_items].max.to_s.length
+      undoc_width = [
+        @undoc_attributes,
+        @undoc_classes,
+        @undoc_constants,
+        @undoc_items,
+        @undoc_methods,
+        @undoc_modules,
+        @undoc_params,
+      ].max.to_s.length
 
-      report << "  # in file #{method.file.full_name}#{line}\n"
-      report << param_report if param_report
-      report << "  def #{scope}#{method.name}#{method.params}; end\n"
+      report = +""
+
+      report << "Files:      %*d\n" % [num_width, @num_files]
+      report << "\n"
+      report << "Classes:    %*d (%*d undocumented)\n" % [
+        num_width, @num_classes, undoc_width, @undoc_classes]
+      report << "Modules:    %*d (%*d undocumented)\n" % [
+        num_width, @num_modules, undoc_width, @undoc_modules]
+      report << "Constants:  %*d (%*d undocumented)\n" % [
+        num_width, @num_constants, undoc_width, @undoc_constants]
+      report << "Attributes: %*d (%*d undocumented)\n" % [
+        num_width, @num_attributes, undoc_width, @undoc_attributes]
+      report << "Methods:    %*d (%*d undocumented)\n" % [
+        num_width, @num_methods, undoc_width, @undoc_methods]
+      report << "Parameters: %*d (%*d undocumented)\n" % [
+        num_width, @num_params, undoc_width, @undoc_params] if
+          @coverage_level > 0
       report << "\n"
+      report << "Total:      %*d (%*d undocumented)\n" % [
+        num_width, @num_items, undoc_width, @undoc_items]
+      report << "%6.2f%% documented\n" % percent_doc
+      report << "\n"
+      report << "Elapsed: %0.1fs\n" % (Time.now - @start)
+
+      report
     end
 
-    report
-  end
+    ##
+    # Determines which parameters in +method+ were not documented.  Returns a
+    # total parameter count and an Array of undocumented methods.
 
-  ##
-  # Returns a summary of the collected statistics.
-
-  def summary
-    calculate
-
-    num_width = [@num_files, @num_items].max.to_s.length
-    undoc_width = [
-      @undoc_attributes,
-      @undoc_classes,
-      @undoc_constants,
-      @undoc_items,
-      @undoc_methods,
-      @undoc_modules,
-      @undoc_params,
-    ].max.to_s.length
-
-    report = RDoc::Markup::Verbatim.new
-
-    report << "Files:      %*d\n" % [num_width, @num_files]
-
-    report << "\n"
-
-    report << "Classes:    %*d (%*d undocumented)\n" % [
-      num_width, @num_classes, undoc_width, @undoc_classes]
-    report << "Modules:    %*d (%*d undocumented)\n" % [
-      num_width, @num_modules, undoc_width, @undoc_modules]
-    report << "Constants:  %*d (%*d undocumented)\n" % [
-      num_width, @num_constants, undoc_width, @undoc_constants]
-    report << "Attributes: %*d (%*d undocumented)\n" % [
-      num_width, @num_attributes, undoc_width, @undoc_attributes]
-    report << "Methods:    %*d (%*d undocumented)\n" % [
-      num_width, @num_methods, undoc_width, @undoc_methods]
-    report << "Parameters: %*d (%*d undocumented)\n" % [
-      num_width, @num_params, undoc_width, @undoc_params] if
-        @coverage_level > 0
-
-    report << "\n"
-
-    report << "Total:      %*d (%*d undocumented)\n" % [
-      num_width, @num_items, undoc_width, @undoc_items]
-
-    report << "%6.2f%% documented\n" % percent_doc
-    report << "\n"
-    report << "Elapsed: %0.1fs\n" % (Time.now - @start)
-
-    RDoc::Markup::Document.new report
-  end
+    def undoc_params(method)
+      @formatter ||= Markup::ToTtOnly.new
 
-  ##
-  # Determines which parameters in +method+ were not documented.  Returns a
-  # total parameter count and an Array of undocumented methods.
+      params = method.param_list
 
-  def undoc_params(method)
-    @formatter ||= RDoc::Markup::ToTtOnly.new
+      params = params.map { |param| param.gsub(/^\*\*?/, '') }
 
-    params = method.param_list
+      return 0, [] if params.empty?
 
-    params = params.map { |param| param.gsub(/^\*\*?/, '') }
+      document = parse method.comment
 
-    return 0, [] if params.empty?
+      tts = document.accept @formatter
 
-    document = parse method.comment
+      undoc = params - tts
 
-    tts = document.accept @formatter
+      [params.length, undoc]
+    end
 
-    undoc = params - tts
+    autoload :Quiet,   "#{__dir__}/stats/quiet"
+    autoload :Normal,  "#{__dir__}/stats/normal"
+    autoload :Verbose, "#{__dir__}/stats/verbose"
 
-    [params.length, undoc]
   end
-
-  autoload :Quiet,   "#{__dir__}/stats/quiet"
-  autoload :Normal,  "#{__dir__}/stats/normal"
-  autoload :Verbose, "#{__dir__}/stats/verbose"
-
 end