rdoc 2.4.1 → 2.4.2

data/lib/rdoc/parser/c.rb

@@ -614,6 +614,7 @@ class RDoc::Parser::C < RDoc::Parser
       if find_body(class_name, meth_body, meth_obj, body) and meth_obj.document_self then
         class_obj.add_method meth_obj
         @stats.add_method meth_obj
+        meth_obj.visibility = :private if 'private_method' == type
       end
     end
   end

data/lib/rdoc/parser/ruby.rb

@@ -1889,7 +1889,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
   end
 
   def parse_class(container, single, tk, comment)
-    container, name_t = get_class_or_module(container)
+    container, name_t = get_class_or_module container
 
     case name_t
     when TkCONSTANT
@@ -1921,9 +1921,9 @@ class RDoc::Parser::Ruby < RDoc::Parser
       else
         other = RDoc::TopLevel.find_class_named(name)
         unless other
-          #            other = @top_level.add_class(NormalClass, name, nil)
-          #            other.record_location(@top_level)
-          #            other.comment = comment
+#          other = @top_level.add_class(NormalClass, name, nil)
+#          other.record_location(@top_level)
+#          other.comment = comment
           other = RDoc::NormalClass.new "Dummy", nil
         end
 
@@ -1948,7 +1948,6 @@ class RDoc::Parser::Ruby < RDoc::Parser
       return
     end
 
-
     nest = 0
     get_tkread
 
@@ -1960,25 +1959,27 @@ class RDoc::Parser::Ruby < RDoc::Parser
     end
 
     loop do
-        case tk
-        when TkSEMICOLON
+      case tk
+      when TkSEMICOLON then
+        break
+      when TkLPAREN, TkfLPAREN, TkLBRACE, TkLBRACK, TkDO, TkIF, TkUNLESS,
+           TkCASE then
+        nest += 1
+      when TkRPAREN, TkRBRACE, TkRBRACK, TkEND then
+        nest -= 1
+      when TkCOMMENT then
+        if nest <= 0 && @scanner.lex_state == EXPR_END
+          unget_tk tk
           break
-        when TkLPAREN, TkfLPAREN, TkLBRACE, TkLBRACK, TkDO
-          nest += 1
-        when TkRPAREN, TkRBRACE, TkRBRACK, TkEND
-          nest -= 1
-        when TkCOMMENT
-          if nest <= 0 && @scanner.lex_state == EXPR_END
-            unget_tk(tk)
-            break
-          end
-        when TkNL
-          if (nest <= 0) && ((@scanner.lex_state == EXPR_END) || (!@scanner.continue))
-            unget_tk(tk)
-            break
-          end
         end
-        tk = get_tk
+      when TkNL then
+        if nest <= 0 &&
+           (@scanner.lex_state == EXPR_END || !@scanner.continue) then
+          unget_tk tk
+          break
+        end
+      end
+      tk = get_tk
     end
 
     res = get_tkread.tr("\n", " ").strip
@@ -1987,9 +1988,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
     con = RDoc::Constant.new name, res, comment
     read_documentation_modifiers con, RDoc::CONSTANT_MODIFIERS
 
-    if con.document_self
-      container.add_constant(con)
-    end
+    container.add_constant con if con.document_self
   end
 
   ##
@@ -2300,33 +2299,37 @@ class RDoc::Parser::Ruby < RDoc::Parser
     nest = 0
 
     loop do
-        case tk
-        when TkSEMICOLON
-          break
-        when TkLBRACE
-          nest += 1
-        when TkRBRACE
-          # we might have a.each {|i| yield i }
-          unget_tk(tk) if nest.zero?
+      case tk
+      when TkSEMICOLON then
+        break
+      when TkLBRACE then
+        nest += 1
+      when TkRBRACE then
+        # we might have a.each {|i| yield i }
+        unget_tk(tk) if nest.zero?
+        nest -= 1
+        break if nest <= 0
+      when TkLPAREN, TkfLPAREN then
+        nest += 1
+      when end_token then
+        if end_token == TkRPAREN
           nest -= 1
-          break if nest <= 0
-        when TkLPAREN, TkfLPAREN
-          nest += 1
-        when end_token
-          if end_token == TkRPAREN
-            nest -= 1
-            break if @scanner.lex_state == EXPR_END and nest <= 0
-          else
-            break unless @scanner.continue
-          end
-        when method && method.block_params.nil? && TkCOMMENT
-          unget_tk(tk)
-          read_documentation_modifiers(method, modifiers)
+          break if @scanner.lex_state == EXPR_END and nest <= 0
+        else
+          break unless @scanner.continue
         end
+      when method && method.block_params.nil? && TkCOMMENT then
+        unget_tk tk
+        read_documentation_modifiers method, modifiers
+        @read.pop
+      when TkCOMMENT then
+        @read.pop
+      end
       tk = get_tk
     end
-    res = get_tkread.tr("\n", " ").strip
-    res = "" if res == ";"
+
+    res = get_tkread.gsub(/\s+/, ' ').strip
+    res = '' if res == ';'
     res
   end
 
@@ -2339,10 +2342,12 @@ class RDoc::Parser::Ruby < RDoc::Parser
   # and add this as the block_params for the method
 
   def parse_method_parameters(method)
-    res = parse_method_or_yield_parameters(method)
-    res = "(" + res + ")" unless res[0] == ?(
+    res = parse_method_or_yield_parameters method
+
+    res = "(#{res})" unless res =~ /\A\(/
     method.params = res unless method.params
-    if method.block_params.nil?
+
+    if method.block_params.nil? then
       skip_tkspace(false)
       read_documentation_modifiers method, RDoc::METHOD_MODIFIERS
     end
@@ -2708,16 +2713,18 @@ class RDoc::Parser::Ruby < RDoc::Parser
   def read_directive(allowed)
     tk = get_tk
     result = nil
-    if TkCOMMENT === tk
-      if tk.text =~ /\s*:?(\w+):\s*(.*)/
+
+    if TkCOMMENT === tk then
+      if tk.text =~ /\s*:?(\w+):\s*(.*)/ then
         directive = $1.downcase
-        if allowed.include?(directive)
+        if allowed.include? directive then
           result = [directive, $2]
         end
       end
     else
-      unget_tk(tk)
+      unget_tk tk
     end
+
     result
   end
 

data/lib/rdoc/rdoc.rb

@@ -18,329 +18,343 @@ require 'fileutils'
 require 'time'
 require 'thread'
 
-module RDoc
+##
+# Encapsulate the production of rdoc documentation. Basically you can use this
+# as you would invoke rdoc from the command line:
+#
+#   rdoc = RDoc::RDoc.new
+#   rdoc.document(args)
+#
+# Where +args+ is an array of strings, each corresponding to an argument you'd
+# give rdoc on the command line. See rdoc/rdoc.rb for details.
+
+class RDoc::RDoc
 
   ##
-  # Encapsulate the production of rdoc documentation. Basically you can use
-  # this as you would invoke rdoc from the command line:
-  #
-  #   rdoc = RDoc::RDoc.new
-  #   rdoc.document(args)
-  #
-  # Where +args+ is an array of strings, each corresponding to an argument
-  # you'd give rdoc on the command line. See rdoc/rdoc.rb for details.
+  # Generator instance used for creating output
 
-  class RDoc
+  attr_accessor :generator
 
-    ##
-    # Generator instance used for creating output
+  ##
+  # RDoc options
 
-    attr_accessor :generator
+  attr_reader :options
 
-    ##
-    # RDoc options
+  ##
+  # Accessor for statistics.  Available after each call to parse_files
 
-    attr_reader :options
+  attr_reader :stats
 
-    ##
-    # Accessor for statistics.  Available after each call to parse_files
+  ##
+  # This is the list of supported output generators
 
-    attr_reader :stats
+  GENERATORS = {}
 
-    ##
-    # This is the list of supported output generators
+  ##
+  # Add +klass+ that can generate output after parsing
 
-    GENERATORS = {}
+  def self.add_generator(klass)
+    name = klass.name.sub(/^RDoc::Generator::/, '').downcase
+    GENERATORS[name] = klass
+  end
 
-    ##
-    # Add +klass+ that can generate output after parsing
+  ##
+  # Active RDoc::RDoc instance
 
-    def self.add_generator(klass)
-      name = klass.name.sub(/^RDoc::Generator::/, '').downcase
-      GENERATORS[name] = klass
-    end
+  def self.current
+    @current
+  end
 
-    ##
-    # Active RDoc::RDoc instance
+  ##
+  # Sets the active RDoc::RDoc instance
 
-    def self.current
-      @current
-    end
+  def self.current=(rdoc)
+    @current = rdoc
+  end
 
-    ##
-    # Sets the active RDoc::RDoc instance
+  def initialize
+    @generator = nil
+    @options = nil
+    @stats = nil
+  end
 
-    def self.current=(rdoc)
-      @current = rdoc
-    end
+  ##
+  # Report an error message and exit
 
-    def initialize
-      @generator = nil
-      @options = nil
-      @stats = nil
-    end
+  def error(msg)
+    raise RDoc::Error, msg
+  end
 
-    ##
-    # Report an error message and exit
+  ##
+  # Turns RDoc from stdin into HTML
 
-    def error(msg)
-      raise ::RDoc::Error, msg
-    end
+  def handle_pipe
+    @html = RDoc::Markup::ToHtml.new
 
-    ##
-    # Create an output dir if it doesn't exist. If it does exist, but doesn't
-    # contain the flag file <tt>created.rid</tt> then we refuse to use it, as
-    # we may clobber some manually generated documentation
+    out = @html.convert $stdin.read
 
-    def setup_output_dir(op_dir, force)
-      flag_file = output_flag_file op_dir
+    $stdout.write out
+  end
 
-      if File.exist? op_dir then
-        unless File.directory? op_dir then
-          error "'#{op_dir}' exists, and is not a directory"
-        end
-        begin
-          created = File.read(flag_file)
-        rescue SystemCallError
-          error "\nDirectory #{op_dir} already exists, but it looks like it\n" +
-            "isn't an RDoc directory. Because RDoc doesn't want to risk\n" +
-            "destroying any of your existing files, you'll need to\n" +
-            "specify a different output directory name (using the\n" +
-            "--op <dir> option).\n\n"
-        else
-          last = (Time.parse(created) unless force rescue nil)
-        end
+  ##
+  # Create an output dir if it doesn't exist. If it does exist, but doesn't
+  # contain the flag file <tt>created.rid</tt> then we refuse to use it, as
+  # we may clobber some manually generated documentation
+
+  def setup_output_dir(op_dir, force)
+    flag_file = output_flag_file op_dir
+
+    if File.exist? op_dir then
+      unless File.directory? op_dir then
+        error "'#{op_dir}' exists, and is not a directory"
+      end
+      begin
+        created = File.read(flag_file)
+      rescue SystemCallError
+        error "\nDirectory #{op_dir} already exists, but it looks like it\n" +
+          "isn't an RDoc directory. Because RDoc doesn't want to risk\n" +
+          "destroying any of your existing files, you'll need to\n" +
+          "specify a different output directory name (using the\n" +
+          "--op <dir> option).\n\n"
       else
-        FileUtils.mkdir_p(op_dir)
+        last = (Time.parse(created) unless force rescue nil)
       end
-      last
+    else
+      FileUtils.mkdir_p(op_dir)
     end
+    last
+  end
 
-    ##
-    # Update the flag file in an output directory.
+  ##
+  # Update the flag file in an output directory.
 
-    def update_output_dir(op_dir, time)
-      File.open(output_flag_file(op_dir), "w") { |f| f.puts time.rfc2822 }
-    end
+  def update_output_dir(op_dir, time)
+    File.open(output_flag_file(op_dir), "w") { |f| f.puts time.rfc2822 }
+  end
+
+  ##
+  # Return the path name of the flag file in an output directory.
+
+  def output_flag_file(op_dir)
+    File.join op_dir, "created.rid"
+  end
 
-    ##
-    # Return the path name of the flag file in an output directory.
+  ##
+  # The .document file contains a list of file and directory name patterns,
+  # representing candidates for documentation. It may also contain comments
+  # (starting with '#')
+
+  def parse_dot_doc_file(in_dir, filename, options)
+    # read and strip comments
+    patterns = File.read(filename).gsub(/#.*/, '')
+
+    result = []
 
-    def output_flag_file(op_dir)
-      File.join op_dir, "created.rid"
+    patterns.split.each do |patt|
+      candidates = Dir.glob(File.join(in_dir, patt))
+      result.concat(normalized_file_list(options,  candidates))
     end
 
-    ##
-    # The .document file contains a list of file and directory name patterns,
-    # representing candidates for documentation. It may also contain comments
-    # (starting with '#')
+    result
+  end
 
-    def parse_dot_doc_file(in_dir, filename, options)
-      # read and strip comments
-      patterns = File.read(filename).gsub(/#.*/, '')
+  ##
+  # Given a list of files and directories, create a list of all the Ruby
+  # files they contain.
+  #
+  # If +force_doc+ is true we always add the given files, if false, only
+  # add files that we guarantee we can parse.  It is true when looking at
+  # files given on the command line, false when recursing through
+  # subdirectories.
+  #
+  # The effect of this is that if you want a file with a non-standard
+  # extension parsed, you must name it explicitly.
 
-      result = []
+  def normalized_file_list(options, relative_files, force_doc = false,
+                           exclude_pattern = nil)
+    file_list = []
 
-      patterns.split.each do |patt|
-        candidates = Dir.glob(File.join(in_dir, patt))
-        result.concat(normalized_file_list(options,  candidates))
-      end
+    relative_files.each do |rel_file_name|
+      next if exclude_pattern && exclude_pattern =~ rel_file_name
+      stat = File.stat rel_file_name rescue next
 
-      result
-    end
+      case type = stat.ftype
+      when "file"
+        next if @last_created and stat.mtime < @last_created
 
-    ##
-    # Given a list of files and directories, create a list of all the Ruby
-    # files they contain.
-    #
-    # If +force_doc+ is true we always add the given files, if false, only
-    # add files that we guarantee we can parse.  It is true when looking at
-    # files given on the command line, false when recursing through
-    # subdirectories.
-    #
-    # The effect of this is that if you want a file with a non-standard
-    # extension parsed, you must name it explicitly.
-
-    def normalized_file_list(options, relative_files, force_doc = false,
-                             exclude_pattern = nil)
-      file_list = []
-
-      relative_files.each do |rel_file_name|
-        next if exclude_pattern && exclude_pattern =~ rel_file_name
-        stat = File.stat rel_file_name rescue next
-
-        case type = stat.ftype
-        when "file"
-          next if @last_created and stat.mtime < @last_created
-
-          if force_doc or ::RDoc::Parser.can_parse(rel_file_name) then
-            file_list << rel_file_name.sub(/^\.\//, '')
-          end
-        when "directory"
-          next if rel_file_name == "CVS" || rel_file_name == ".svn"
-          dot_doc = File.join(rel_file_name, DOT_DOC_FILENAME)
-          if File.file?(dot_doc)
-            file_list.concat(parse_dot_doc_file(rel_file_name, dot_doc, options))
-          else
-            file_list.concat(list_files_in_directory(rel_file_name, options))
-          end
+        if force_doc or RDoc::Parser.can_parse(rel_file_name) then
+          file_list << rel_file_name.sub(/^\.\//, '')
+        end
+      when "directory"
+        next if rel_file_name == "CVS" || rel_file_name == ".svn"
+        dot_doc = File.join(rel_file_name, RDoc::DOT_DOC_FILENAME)
+        if File.file?(dot_doc)
+          file_list.concat(parse_dot_doc_file(rel_file_name, dot_doc, options))
         else
-          raise RDoc::Error, "I can't deal with a #{type} #{rel_file_name}"
+          file_list.concat(list_files_in_directory(rel_file_name, options))
         end
+      else
+        raise RDoc::Error, "I can't deal with a #{type} #{rel_file_name}"
       end
-
-      file_list
     end
 
-    ##
-    # Return a list of the files to be processed in a directory. We know that
-    # this directory doesn't have a .document file, so we're looking for real
-    # files. However we may well contain subdirectories which must be tested
-    # for .document files.
+    file_list
+  end
+
+  ##
+  # Return a list of the files to be processed in a directory. We know that
+  # this directory doesn't have a .document file, so we're looking for real
+  # files. However we may well contain subdirectories which must be tested
+  # for .document files.
 
-    def list_files_in_directory(dir, options)
-      files = Dir.glob File.join(dir, "*")
+  def list_files_in_directory(dir, options)
+    files = Dir.glob File.join(dir, "*")
 
-      normalized_file_list options, files, false, options.exclude
-    end
+    normalized_file_list options, files, false, options.exclude
+  end
 
-    ##
-    # Parse each file on the command line, recursively entering directories.
+  ##
+  # Parse each file on the command line, recursively entering directories.
 
-    def parse_files(options)
-      files = options.files
-      files = ["."] if files.empty?
+  def parse_files(options)
+    files = options.files
+    files = ["."] if files.empty?
 
-      file_list = normalized_file_list(options, files, true, options.exclude)
+    file_list = normalized_file_list(options, files, true, options.exclude)
 
-      return [] if file_list.empty?
+    return [] if file_list.empty?
 
-      jobs = SizedQueue.new(@options.threads * 3)
-      workers = []
-      file_info = []
-      file_info_lock = Mutex.new
+    jobs = SizedQueue.new(@options.threads * 3)
+    workers = []
+    file_info = []
+    file_info_lock = Mutex.new
 
-      Thread.abort_on_exception = true
-      @stats = Stats.new(file_list.size, options.verbosity)
-      @stats.begin_adding @options.threads
+    Thread.abort_on_exception = true
+    @stats = RDoc::Stats.new(file_list.size, options.verbosity)
+    @stats.begin_adding @options.threads
 
-      # Create worker threads.
-      @options.threads.times do
-        thread = Thread.new do
-          while (filename = jobs.pop)
-            @stats.add_file(filename)
-            content = read_file_contents(filename)
-            top_level = ::RDoc::TopLevel.new filename
+    # Create worker threads.
+    @options.threads.times do
+      thread = Thread.new do
+        while (filename = jobs.pop)
+          @stats.add_file(filename)
+          content = read_file_contents(filename)
+          top_level = RDoc::TopLevel.new filename
 
-            parser = ::RDoc::Parser.for(top_level, filename, content, options,
-                                        @stats)
-            result = parser.scan
+          parser = RDoc::Parser.for(top_level, filename, content, options,
+                                    @stats)
+          result = parser.scan
 
-            file_info_lock.synchronize do
-              file_info << result
-            end
+          file_info_lock.synchronize do
+            file_info << result
           end
         end
-        workers << thread
       end
+      workers << thread
+    end
 
-      # Feed filenames to the parser worker threads...
-      file_list.each do |filename|
-        jobs << filename
-      end
-      workers.size.times do
-        jobs << nil
-      end
+    # Feed filenames to the parser worker threads...
+    file_list.each do |filename|
+      jobs << filename
+    end
+    workers.size.times do
+      jobs << nil
+    end
 
-      # ...and wait until they're done.
-      workers.each do |thread|
-        thread.join
-      end
+    # ...and wait until they're done.
+    workers.each do |thread|
+      thread.join
+    end
 
-      @stats.done_adding
+    @stats.done_adding
 
-      file_info
-    end
+    file_info
+  end
 
-    ##
-    # Format up one or more files according to the given arguments.
-    #
-    # For simplicity, _argv_ is an array of strings, equivalent to the strings
-    # that would be passed on the command line. (This isn't a coincidence, as
-    # we _do_ pass in ARGV when running interactively). For a list of options,
-    # see rdoc/rdoc.rb. By default, output will be stored in a directory
-    # called +doc+ below the current directory, so make sure you're somewhere
-    # writable before invoking.
-    #
-    # Throws: RDoc::Error on error
+  ##
+  # Format up one or more files according to the given arguments.
+  #
+  # For simplicity, _argv_ is an array of strings, equivalent to the strings
+  # that would be passed on the command line. (This isn't a coincidence, as
+  # we _do_ pass in ARGV when running interactively). For a list of options,
+  # see rdoc/rdoc.rb. By default, output will be stored in a directory
+  # called +doc+ below the current directory, so make sure you're somewhere
+  # writable before invoking.
+  #
+  # Throws: RDoc::Error on error
 
-    def document(argv)
-      TopLevel.reset
+  def document(argv)
+    RDoc::TopLevel.reset
 
-      @options = Options.new
-      @options.parse argv
+    @options = RDoc::Options.new
+    @options.parse argv
 
-      @last_created = setup_output_dir @options.op_dir, @options.force_update
+    if @options.pipe then
+      handle_pipe
+      exit
+    end
 
-      start_time = Time.now
+    @last_created = setup_output_dir @options.op_dir, @options.force_update
 
-      file_info = parse_files @options
+    start_time = Time.now
 
-      @options.title = "RDoc Documentation"
+    file_info = parse_files @options
 
-      if file_info.empty?
-        $stderr.puts "\nNo newer files." unless @options.quiet
-      else
-        gen_klass = @options.generator
+    @options.title = "RDoc Documentation"
 
-        unless @options.quiet then
-          $stderr.puts "\nGenerating #{gen_klass.name.sub(/^.*::/, '')}..."
-        end
+    if file_info.empty?
+      $stderr.puts "\nNo newer files." unless @options.quiet
+    else
+      gen_klass = @options.generator
 
-        @generator = gen_klass.for @options
+      unless @options.quiet then
+        $stderr.puts "\nGenerating #{gen_klass.name.sub(/^.*::/, '')}..."
+      end
 
-        pwd = Dir.pwd
+      @generator = gen_klass.for @options
 
-        Dir.chdir @options.op_dir
+      pwd = Dir.pwd
 
-        begin
-          self.class.current = self
+      Dir.chdir @options.op_dir
 
-          Diagram.new(file_info, @options).draw if @options.diagram
-          @generator.generate file_info
-          update_output_dir ".", start_time
-        ensure
-          self.class.current = nil
-          Dir.chdir pwd
-        end
-      end
+      begin
+        self.class.current = self
 
-      unless @options.quiet or not @stats then
-        puts
-        @stats.print
+        RDoc::Diagram.new(file_info, @options).draw if @options.diagram
+        @generator.generate file_info
+        update_output_dir ".", start_time
+      ensure
+        self.class.current = nil
+        Dir.chdir pwd
       end
     end
 
-    private
+    unless @options.quiet or not @stats then
+      puts
+      @stats.print
+    end
+  end
+
+  private
 
-    def read_file_contents(filename)
-      content = if RUBY_VERSION >= '1.9' then
-                  File.open(filename, "r:ascii-8bit") { |f| f.read }
-                else
-                  File.read filename
-                end
+  def read_file_contents(filename)
+    content = if RUBY_VERSION >= '1.9' then
+                File.open(filename, "r:ascii-8bit") { |f| f.read }
+              else
+                File.read filename
+              end
 
-      if defined? Encoding then
-        if /coding:\s*(\S+)/ =~ content[/\A(?:.*\n){0,2}/]
-          if enc = ::Encoding.find($1)
-            content.force_encoding(enc)
-          end
+    if defined? Encoding then
+      if /coding:\s*(\S+)/ =~ content[/\A(?:.*\n){0,2}/]
+        if enc = ::Encoding.find($1)
+          content.force_encoding(enc)
         end
       end
-
-      content
     end
+
+    content
   end
+
 end
 
 if Gem.respond_to? :find_files then