rdoc 3.1 → 6.3.3

data/lib/rdoc/code_object.rb

@@ -1,6 +1,4 @@
-require 'rdoc'
-require 'rdoc/text'
-
+# frozen_string_literal: true
 ##
 # Base class for the RDoc code tree.
 #
@@ -23,8 +21,9 @@ require 'rdoc/text'
 #     * RDoc::MetaMethod
 # * RDoc::Alias
 # * RDoc::Constant
-# * RDoc::Require
-# * RDoc::Include
+# * RDoc::Mixin
+#   * RDoc::Require
+#   * RDoc::Include
 
 class RDoc::CodeObject
 
@@ -60,15 +59,20 @@ class RDoc::CodeObject
 
   attr_reader :force_documentation
 
+  ##
+  # Line in #file where this CodeObject was defined
+
+  attr_accessor :line
+
   ##
   # Hash of arbitrary metadata for this CodeObject
 
   attr_reader :metadata
 
   ##
-  # Our parent CodeObject
+  # Sets the parent CodeObject
 
-  attr_accessor :parent
+  attr_writer :parent
 
   ##
   # Did we ever receive a +:nodoc:+ directive?
@@ -76,9 +80,14 @@ class RDoc::CodeObject
   attr_reader :received_nodoc
 
   ##
-  # Which section are we in
+  # Set the section this CodeObject is in
+
+  attr_writer :section
+
+  ##
+  # The RDoc::Store for this object.
 
-  attr_accessor :section
+  attr_reader :store
 
   ##
   # We are the model of the code, but we know that at some point we will be
@@ -91,17 +100,33 @@ class RDoc::CodeObject
   # Creates a new CodeObject that will document itself and its children
 
   def initialize
-    @metadata  = {}
-    @comment   = ''
-    @parent    = nil
-    @file      = nil
-    @full_name = nil
+    @metadata         = {}
+    @comment          = ''
+    @parent           = nil
+    @parent_name      = nil # for loading
+    @parent_class     = nil # for loading
+    @section          = nil
+    @section_title    = nil # for loading
+    @file             = nil
+    @full_name        = nil
+    @store            = nil
+    @track_visibility = true
+
+    initialize_visibility
+  end
+
+  ##
+  # Initializes state for visibility of this CodeObject and its children.
 
+  def initialize_visibility # :nodoc:
     @document_children   = true
     @document_self       = true
     @done_documenting    = false
     @force_documentation = false
     @received_nodoc      = false
+    @ignored             = false
+    @suppressed          = false
+    @track_visibility    = true
   end
 
   ##
@@ -111,20 +136,42 @@ class RDoc::CodeObject
     @comment = case comment
                when NilClass               then ''
                when RDoc::Markup::Document then comment
+               when RDoc::Comment          then comment.normalize
                else
                  if comment and not comment.empty? then
                    normalize_comment comment
                  else
+                   # HACK correct fix is to have #initialize create @comment
+                   #      with the correct encoding
+                   if String === @comment and @comment.empty? then
+                     @comment = RDoc::Encoding.change_encoding @comment, comment.encoding
+                   end
                    @comment
                  end
                end
   end
 
+  ##
+  # Should this CodeObject be displayed in output?
+  #
+  # A code object should be displayed if:
+  #
+  # * The item didn't have a nodoc or wasn't in a container that had nodoc
+  # * The item wasn't ignored
+  # * The item has documentation and was not suppressed
+
+  def display?
+    @document_self and not @ignored and
+      (documented? or not @suppressed)
+  end
+
   ##
   # Enables or disables documentation of this CodeObject's children unless it
   # has been turned off by :enddoc:
 
   def document_children=(document_children)
+    return unless @track_visibility
+
     @document_children = document_children unless @done_documenting
   end
 
@@ -134,6 +181,7 @@ class RDoc::CodeObject
   # documentation is turned off by +:nodoc:+.
 
   def document_self=(document_self)
+    return unless @track_visibility
     return if @done_documenting
 
     @document_self = document_self
@@ -157,14 +205,40 @@ class RDoc::CodeObject
   # will have no effect in the current file.
 
   def done_documenting=(value)
-    @done_documenting = value
-    @document_self = !value
+    return unless @track_visibility
+    @done_documenting  = value
+    @document_self     = !value
     @document_children = @document_self
   end
 
+  ##
+  # Yields each parent of this CodeObject.  See also
+  # RDoc::ClassModule#each_ancestor
+
+  def each_parent
+    code_object = self
+
+    while code_object = code_object.parent do
+      yield code_object
+    end
+
+    self
+  end
+
+  ##
+  # File name where this CodeObject was found.
+  #
+  # See also RDoc::Context#in_files
+
+  def file_name
+    return unless @file
+
+    @file.absolute_name
+  end
+
   ##
   # Force the documentation of this object unless documentation
-  # has been turned off by :endoc:
+  # has been turned off by :enddoc:
   #--
   # HACK untested, was assigning to an ivar
 
@@ -181,6 +255,76 @@ class RDoc::CodeObject
     @full_name = full_name
   end
 
+  ##
+  # Use this to ignore a CodeObject and all its children until found again
+  # (#record_location is called).  An ignored item will not be displayed in
+  # documentation.
+  #
+  # See github issue #55
+  #
+  # The ignored status is temporary in order to allow implementation details
+  # to be hidden.  At the end of processing a file RDoc allows all classes
+  # and modules to add new documentation to previously created classes.
+  #
+  # If a class was ignored (via stopdoc) then reopened later with additional
+  # documentation it should be displayed.  If a class was ignored and never
+  # reopened it should not be displayed.  The ignore flag allows this to
+  # occur.
+
+  def ignore
+    return unless @track_visibility
+
+    @ignored = true
+
+    stop_doc
+  end
+
+  ##
+  # Has this class been ignored?
+  #
+  # See also #ignore
+
+  def ignored?
+    @ignored
+  end
+
+  ##
+  # The options instance from the store this CodeObject is attached to, or a
+  # default options instance if the CodeObject is not attached.
+  #
+  # This is used by Text#snippet
+
+  def options
+    if @store and @store.rdoc then
+      @store.rdoc.options
+    else
+      RDoc::Options.new
+    end
+  end
+
+  ##
+  # Our parent CodeObject.  The parent may be missing for classes loaded from
+  # legacy RI data stores.
+
+  def parent
+    return @parent if @parent
+    return nil unless @parent_name
+
+    if @parent_class == RDoc::TopLevel then
+      @parent = @store.add_file @parent_name
+    else
+      @parent = @store.find_class_or_module @parent_name
+
+      return @parent if @parent
+
+      begin
+        @parent = @store.load_class @parent_name
+      rescue RDoc::Store::MissingFileError
+        nil
+      end
+    end
+  end
+
   ##
   # File name of our parent
 
@@ -199,27 +343,79 @@ class RDoc::CodeObject
   # Records the RDoc::TopLevel (file) where this code object was defined
 
   def record_location top_level
-    @file = top_level
+    @ignored    = false
+    @suppressed = false
+    @file       = top_level
+  end
+
+  ##
+  # The section this CodeObject is in.  Sections allow grouping of constants,
+  # attributes and methods inside a class or module.
+
+  def section
+    return @section if @section
+
+    @section = parent.add_section @section_title if parent
   end
 
   ##
   # Enable capture of documentation unless documentation has been
-  # turned off by :endoc:
+  # turned off by :enddoc:
 
   def start_doc
     return if @done_documenting
 
     @document_self = true
     @document_children = true
+    @ignored    = false
+    @suppressed = false
   end
 
   ##
   # Disable capture of documentation
 
   def stop_doc
+    return unless @track_visibility
+
     @document_self = false
     @document_children = false
   end
 
-end
+  ##
+  # Sets the +store+ that contains this CodeObject
+
+  def store= store
+    @store = store
+
+    return unless @track_visibility
+
+    if :nodoc == options.visibility then
+      initialize_visibility
+      @track_visibility = false
+    end
+  end
+
+  ##
+  # Use this to suppress a CodeObject and all its children until the next file
+  # it is seen in or documentation is discovered.  A suppressed item with
+  # documentation will be displayed while an ignored item with documentation
+  # may not be displayed.
+
+  def suppress
+    return unless @track_visibility
 
+    @suppressed = true
+
+    stop_doc
+  end
+
+  ##
+  # Has this class been suppressed?
+  #
+  # See also #suppress
+
+  def suppressed?
+    @suppressed
+  end
+
+end

data/lib/rdoc/code_objects.rb

@@ -1,23 +1,6 @@
-# We represent the various high-level code constructs that appear in Ruby
-# programs: classes, modules, methods, and so on.
+# frozen_string_literal: true
+# This file was used to load all the RDoc::CodeObject subclasses at once.  Now
+# autoload handles this.
 
-require 'rdoc/code_object'
-require 'rdoc/context'
-require 'rdoc/top_level'
-
-require 'rdoc/class_module'
-require 'rdoc/normal_class'
-require 'rdoc/normal_module'
-require 'rdoc/anon_class'
-require 'rdoc/single_class'
-
-require 'rdoc/any_method'
-require 'rdoc/alias'
-require 'rdoc/ghost_method'
-require 'rdoc/meta_method'
-
-require 'rdoc/attr'
-require 'rdoc/constant'
-require 'rdoc/require'
-require 'rdoc/include'
+require 'rdoc'
 

data/lib/rdoc/comment.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+##
+# A comment holds the text comment for a RDoc::CodeObject and provides a
+# unified way of cleaning it up and parsing it into an RDoc::Markup::Document.
+#
+# Each comment may have a different markup format set by #format=.  By default
+# 'rdoc' is used.  The :markup: directive tells RDoc which format to use.
+#
+# See RDoc::Markup@Other+directives for instructions on adding an alternate
+# format.
+
+class RDoc::Comment
+
+  include RDoc::Text
+
+  ##
+  # The format of this comment.  Defaults to RDoc::Markup
+
+  attr_reader :format
+
+  ##
+  # The RDoc::TopLevel this comment was found in
+
+  attr_accessor :location
+
+  ##
+  # Line where this Comment was written
+
+  attr_accessor :line
+
+  ##
+  # For duck-typing when merging classes at load time
+
+  alias file location # :nodoc:
+
+  ##
+  # The text for this comment
+
+  attr_reader :text
+
+  ##
+  # Alias for text
+
+  alias to_s text
+
+  ##
+  # Overrides the content returned by #parse.  Use when there is no #text
+  # source for this comment
+
+  attr_writer   :document
+
+  ##
+  # Creates a new comment with +text+ that is found in the RDoc::TopLevel
+  # +location+.
+
+  def initialize text = nil, location = nil, language = nil
+    @location = location
+    @text     = text.nil? ? nil : text.dup
+    @language = language
+
+    @document   = nil
+    @format     = 'rdoc'
+    @normalized = false
+  end
+
+  ##
+  #--
+  # TODO deep copy @document
+
+  def initialize_copy copy # :nodoc:
+    @text = copy.text.dup
+  end
+
+  def == other # :nodoc:
+    self.class === other and
+      other.text == @text and other.location == @location
+  end
+
+  ##
+  # Look for a 'call-seq' in the comment to override the normal parameter
+  # handling.  The :call-seq: is indented from the baseline.  All lines of the
+  # same indentation level and prefix are consumed.
+  #
+  # For example, all of the following will be used as the :call-seq:
+  #
+  #   # :call-seq:
+  #   #   ARGF.readlines(sep=$/)     -> array
+  #   #   ARGF.readlines(limit)      -> array
+  #   #   ARGF.readlines(sep, limit) -> array
+  #   #
+  #   #   ARGF.to_a(sep=$/)     -> array
+  #   #   ARGF.to_a(limit)      -> array
+  #   #   ARGF.to_a(sep, limit) -> array
+
+  def extract_call_seq method
+    # we must handle situations like the above followed by an unindented first
+    # comment.  The difficulty is to make sure not to match lines starting
+    # with ARGF at the same indent, but that are after the first description
+    # paragraph.
+    if @text =~ /^\s*:?call-seq:(.*?(?:\S).*?)^\s*$/m then
+      all_start, all_stop = $~.offset(0)
+      seq_start, seq_stop = $~.offset(1)
+
+      # we get the following lines that start with the leading word at the
+      # same indent, even if they have blank lines before
+      if $1 =~ /(^\s*\n)+^(\s*\w+)/m then
+        leading = $2 # ' *    ARGF' in the example above
+        re = %r%
+          \A(
+             (^\s*\n)+
+             (^#{Regexp.escape leading}.*?\n)+
+            )+
+          ^\s*$
+        %xm
+
+        if @text[seq_stop..-1] =~ re then
+          all_stop = seq_stop + $~.offset(0).last
+          seq_stop = seq_stop + $~.offset(1).last
+        end
+      end
+
+      seq = @text[seq_start..seq_stop]
+      seq.gsub!(/^\s*(\S|\n)/m, '\1')
+      @text.slice! all_start...all_stop
+
+      method.call_seq = seq.chomp
+
+    else
+      regexp = /^\s*:?call-seq:(.*?)(^\s*$|\z)/m
+      if regexp =~ @text then
+        @text = @text.sub(regexp, '')
+        seq = $1
+        seq.gsub!(/^\s*/, '')
+        method.call_seq = seq
+      end
+    end
+
+    method
+  end
+
+  ##
+  # A comment is empty if its text String is empty.
+
+  def empty?
+    @text.empty?
+  end
+
+  ##
+  # HACK dubious
+
+  def encode! encoding
+    # TODO: Remove this condition after Ruby 2.2 EOL
+    if RUBY_VERSION < '2.3.0'
+      @text = @text.force_encoding encoding
+    else
+      @text = String.new @text, encoding: encoding
+    end
+    self
+  end
+
+  ##
+  # Sets the format of this comment and resets any parsed document
+
+  def format= format
+    @format = format
+    @document = nil
+  end
+
+  def inspect # :nodoc:
+    location = @location ? @location.relative_name : '(unknown)'
+
+    "#<%s:%x %s %p>" % [self.class, object_id, location, @text]
+  end
+
+  ##
+  # Normalizes the text.  See RDoc::Text#normalize_comment for details
+
+  def normalize
+    return self unless @text
+    return self if @normalized # TODO eliminate duplicate normalization
+
+    @text = normalize_comment @text
+
+    @normalized = true
+
+    self
+  end
+
+  ##
+  # Was this text normalized?
+
+  def normalized? # :nodoc:
+    @normalized
+  end
+
+  ##
+  # Parses the comment into an RDoc::Markup::Document.  The parsed document is
+  # cached until the text is changed.
+
+  def parse
+    return @document if @document
+
+    @document = super @text, @format
+    @document.file = @location
+    @document
+  end
+
+  ##
+  # Removes private sections from this comment.  Private sections are flush to
+  # the comment marker and start with <tt>--</tt> and end with <tt>++</tt>.
+  # For C-style comments, a private marker may not start at the opening of the
+  # comment.
+  #
+  #   /*
+  #    *--
+  #    * private
+  #    *++
+  #    * public
+  #    */
+
+  def remove_private
+    # Workaround for gsub encoding for Ruby 1.9.2 and earlier
+    empty = ''
+    empty = RDoc::Encoding.change_encoding empty, @text.encoding
+
+    @text = @text.gsub(%r%^\s*([#*]?)--.*?^\s*(\1)\+\+\n?%m, empty)
+    @text = @text.sub(%r%^\s*[#*]?--.*%m, '')
+  end
+
+  ##
+  # Replaces this comment's text with +text+ and resets the parsed document.
+  #
+  # An error is raised if the comment contains a document but no text.
+
+  def text= text
+    raise RDoc::Error, 'replacing document-only comment is not allowed' if
+      @text.nil? and @document
+
+    @document = nil
+    @text = text.nil? ? nil : text.dup
+  end
+
+  ##
+  # Returns true if this comment is in TomDoc format.
+
+  def tomdoc?
+    @format == 'tomdoc'
+  end
+
+end