rdoc 2.1.0 → 2.2.0

data/lib/rdoc/markup/to_texinfo.rb

@@ -30,7 +30,7 @@ class RDoc::Markup::ToTexInfo < RDoc::Markup::Formatter
 
   def accept_heading(attributes, text)
     heading = ['@majorheading', '@chapheading'][text.head_level - 1] || '@heading'
-    @text << "#{heading}{#{format(text)}}"
+    @text << "#{heading} #{format(text)}"
   end
 
   def accept_list_start(attributes, text)

data/lib/rdoc/parser.rb

@@ -62,11 +62,32 @@ class RDoc::Parser
     true
   end
 
+  ##
+  # Shamelessly stolen from the ptools gem (since RDoc cannot depend on
+  # the gem).
+
+  def self.binary?(file)
+    s = (File.read(file, File.stat(file).blksize) || "").split(//)
+    ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
+  end
+  private_class_method :binary?
+
   ##
   # Return a parser that can handle a particular extension
 
   def self.can_parse(file_name)
-    RDoc::Parser.parsers.find { |regexp, parser| regexp =~ file_name }.last
+    parser = RDoc::Parser.parsers.find { |regexp, parser| regexp =~ file_name }.last
+
+    #
+    # The default parser should *NOT* parse binary files.
+    #
+    if parser == RDoc::Parser::Simple then
+      if binary? file_name then
+        return nil
+      end
+    end
+
+    return parser
   end
 
   ##

data/lib/rdoc/parser/c.rb

@@ -270,7 +270,7 @@ class RDoc::Parser::C < RDoc::Parser
   def find_body(meth_name, meth_obj, body, quiet = false)
     case body
     when %r"((?>/\*.*?\*/\s*))(?:static\s+)?VALUE\s+#{meth_name}
-            \s*(\([^)]*\))\s*\{.*?^\}"xm
+            \s*(\([^)]*\))([^;]|$)"xm
       comment, params = $1, $2
       body_text = $&
 
@@ -279,9 +279,7 @@ class RDoc::Parser::C < RDoc::Parser
       # see if we can find the whole body
 
       re = Regexp.escape(body_text) + '[^(]*^\{.*?^\}'
-      if Regexp.new(re, Regexp::MULTILINE).match(body)
-        body_text = $&
-      end
+      body_text = $& if /#{re}/m =~ body
 
       # The comment block may have been overridden with a 'Document-method'
       # block. This happens in the interpreter when multiple methods are
@@ -562,18 +560,16 @@ class RDoc::Parser::C < RDoc::Parser
 
     return unless class_name
 
-    class_obj  = find_class(var_name, class_name)
+    class_obj = find_class var_name, class_name
 
-    if class_obj
-      if meth_name == "initialize"
+    if class_obj then
+      if meth_name == "initialize" then
         meth_name = "new"
         type = "singleton_method"
       end
-      meth_obj = RDoc::AnyMethod.new("", meth_name)
-      meth_obj.singleton =
-  %w{singleton_method module_function}.include?(type)
 
-      @stats.add_method meth_obj
+      meth_obj = RDoc::AnyMethod.new '', meth_name
+      meth_obj.singleton = %w[singleton_method module_function].include? type
 
       p_count = (Integer(param_count) rescue -1)
 
@@ -585,14 +581,16 @@ class RDoc::Parser::C < RDoc::Parser
         meth_obj.params = "(" + (1..p_count).map{|i| "p#{i}"}.join(", ") + ")"
       end
 
-      if source_file
+      if source_file then
         file_name = File.join(@file_dir, source_file)
         body = (@@known_bodies[source_file] ||= File.read(file_name))
       else
         body = @content
       end
-      if find_body(meth_body, meth_obj, body) and meth_obj.document_self
-        class_obj.add_method(meth_obj)
+
+      if find_body(meth_body, meth_obj, body) and meth_obj.document_self then
+        class_obj.add_method meth_obj
+        @stats.add_method meth_obj
       end
     end
   end
@@ -628,8 +626,8 @@ class RDoc::Parser::C < RDoc::Parser
   end
 
   def remove_private_comments(comment)
-     comment.gsub!(/\/?\*--(.*?)\/?\*\+\+/m, '')
-     comment.sub!(/\/?\*--.*/m, '')
+     comment.gsub!(/\/?\*--\n(.*?)\/?\*\+\+/m, '')
+     comment.sub!(/\/?\*--\n.*/m, '')
   end
 
   ##

data/lib/rdoc/parser/ruby.rb

@@ -134,7 +134,7 @@ module RDoc::RubyToken
 
   TokenDefinitions = [
     [:TkCLASS,      TkKW,  "class",  EXPR_CLASS],
-    [:TkMODULE,     TkKW,  "module", EXPR_BEG],
+    [:TkMODULE,     TkKW,  "module", EXPR_CLASS],
     [:TkDEF,        TkKW,  "def",    EXPR_FNAME],
     [:TkUNDEF,      TkKW,  "undef",  EXPR_FNAME],
     [:TkBEGIN,      TkKW,  "begin",  EXPR_BEG],
@@ -2683,8 +2683,8 @@ class RDoc::Parser::Ruby < RDoc::Parser
   end
 
   def remove_private_comments(comment)
-    comment.gsub!(/^#--.*?^#\+\+/m, '')
-    comment.sub!(/^#--.*/m, '')
+    comment.gsub!(/^#--\n.*?^#\+\+/m, '')
+    comment.sub!(/^#--\n.*/m, '')
   end
 
   def remove_token_listener(obj)

data/lib/rdoc/parser/simple.rb

@@ -31,7 +31,7 @@ class RDoc::Parser::Simple < RDoc::Parser
   end
 
   def remove_private_comments(comment)
-    comment.gsub(/^--[^-].*?^\+\+/m, '').sub(/^--.*/m, '')
+    comment.gsub(/^--\n.*?^\+\+/m, '').sub(/^--\n.*/m, '')
   end
 
 end

data/lib/rdoc/rdoc.rb

@@ -288,6 +288,5 @@ module RDoc
       end
     end
   end
-
 end
 

data/lib/rdoc/ri/cache.rb

@@ -14,7 +14,7 @@ class RDoc::RI::ClassEntry
     @inferior_classes = []
   end
 
-  # We found this class in more tha one place, so add
+  # We found this class in more than one place, so add
   # in the name from there.
   def add_path(path)
     @path_names << path
@@ -37,10 +37,10 @@ class RDoc::RI::ClassEntry
       if name =~ /^(.*?)-(c|i).yaml$/
         external_name = $1
         is_class_method = $2 == "c"
-        internal_name = RiWriter.external_to_internal(external_name)
+        internal_name = RDoc::RI::Writer.external_to_internal(external_name)
         list = is_class_method ? @class_methods : @instance_methods
         path = File.join(dir, name)
-        list << MethodEntry.new(path, internal_name, is_class_method, self)
+        list << RDoc::RI::MethodEntry.new(path, internal_name, is_class_method, self)
       else
         full_name = File.join(dir, name)
         if File.directory?(full_name)
@@ -48,7 +48,7 @@ class RDoc::RI::ClassEntry
           if inf_class
             inf_class.add_path(full_name)
           else
-            inf_class = ClassEntry.new(full_name, name, self)
+            inf_class = RDoc::RI::ClassEntry.new(full_name, name, self)
             @inferior_classes << inf_class
           end
           inf_class.load_from(full_name)
@@ -168,7 +168,7 @@ class RDoc::RI::MethodEntry
 end
 
 ##
-# We represent everything know about all 'ri' files accessible to this program
+# We represent everything known about all 'ri' files accessible to this program
 
 class RDoc::RI::Cache
 
@@ -185,4 +185,3 @@ class RDoc::RI::Cache
   end
 
 end
-

data/lib/rdoc/ri/descriptions.rb

@@ -77,7 +77,9 @@ end
 class RDoc::RI::ModuleDescription < RDoc::RI::Description
 
   attr_accessor :class_methods
+  attr_accessor :class_method_extensions
   attr_accessor :instance_methods
+  attr_accessor :instance_method_extensions
   attr_accessor :attributes
   attr_accessor :constants
   attr_accessor :includes
@@ -148,6 +150,7 @@ class RDoc::RI::MethodDescription < RDoc::RI::Description
   attr_accessor :aliases
   attr_accessor :is_alias_for
   attr_accessor :params
+  attr_accessor :source_path
 
 end
 

data/lib/rdoc/ri/display.rb

@@ -1,5 +1,15 @@
 require 'rdoc/ri'
 
+# readline support might not be present, so be careful
+# when requiring it.
+begin
+  require('readline')
+  require('abbrev')
+  CAN_USE_READLINE = true
+rescue
+  CAN_USE_READLINE = false
+end
+
 ##
 # This is a kind of 'flag' module. If you want to write your own 'ri' display
 # module (perhaps because you're writing an IDE), you write a class which
@@ -41,7 +51,7 @@ class RDoc::RI::DefaultDisplay
   # Display information about +klass+.  Fetches additional information from
   # +ri_reader+ as necessary.
 
-  def display_class_info(klass, ri_reader)
+  def display_class_info(klass)
     page do
       superclass = klass.superclass_string
 
@@ -61,17 +71,11 @@ class RDoc::RI::DefaultDisplay
         @formatter.blankline
         @formatter.display_heading("Includes:", 2, "")
         incs = []
+
         klass.includes.each do |inc|
-          inc_desc = ri_reader.find_class_by_name(inc.name)
-          if inc_desc
-            str = inc.name + "("
-            str << inc_desc.instance_methods.map{|m| m.name}.join(", ")
-            str << ")"
-            incs << str
-          else
-            incs << inc.name
-          end
-      end
+          incs << inc.name
+        end
+
         @formatter.wrap(incs.sort.join(', '))
       end
 
@@ -94,27 +98,6 @@ class RDoc::RI::DefaultDisplay
         end
       end
 
-      class_data = [
-        :class_methods,
-        :class_method_extensions,
-        :instance_methods,
-        :instance_method_extensions,
-      ]
-
-      class_data.each do |data_type|
-        data = klass.send data_type
-
-        unless data.empty? then
-          @formatter.blankline
-
-          heading = data_type.to_s.split('_').join(' ').capitalize << ':'
-          @formatter.display_heading heading, 2, ''
-
-          data = data.map { |item| item.name }.sort.join ', '
-          @formatter.wrap data
-        end
-      end
-
       unless klass.attributes.empty? then
         @formatter.blankline
 
@@ -133,8 +116,115 @@ class RDoc::RI::DefaultDisplay
           end
         end
       end
+
+      return display_class_method_list(klass)
     end
   end
+  
+  ##
+  # Given a Hash mapping a class' methods to method types (returned by
+  # display_class_method_list), this method allows the user to
+  # choose one of the methods.
+  
+  def get_class_method_choice(method_map)
+    if CAN_USE_READLINE
+      # prepare abbreviations for tab completion
+      abbreviations = method_map.keys.abbrev
+      Readline.completion_proc = proc do |string| 
+        abbreviations.values.uniq.grep(/^#{string}/)
+      end
+    end
+    
+    @formatter.raw_print_line "\nEnter the method name you want.\n"
+    @formatter.raw_print_line "Class methods can be preceeded by '::' and instance methods by '#'.\n"
+
+    if CAN_USE_READLINE
+      @formatter.raw_print_line "You can use tab to autocomplete.\n"
+      @formatter.raw_print_line "Enter a blank line to exit.\n"
+      
+      choice_string = Readline.readline(">> ").strip
+    else
+      @formatter.raw_print_line "Enter a blank line to exit.\n"
+      @formatter.raw_print_line ">> "
+      choice_string = $stdin.gets.strip
+    end
+    
+    if choice_string == ''
+      return nil
+    else
+      class_or_instance = method_map[choice_string]
+
+      if class_or_instance
+        # If the user's choice is not preceeded by a '::' or a '#', figure
+        # out whether they want a class or an instance method and decorate
+        # the choice appropriately.
+        if(choice_string =~ /^[a-zA-Z]/)
+          if(class_or_instance == :class)
+            choice_string = "::#{choice_string}"
+          else
+            choice_string = "##{choice_string}"
+          end
+        end
+
+        return choice_string
+      else
+        @formatter.raw_print_line "No method matched '#{choice_string}'.\n"
+        return nil
+      end
+    end
+  end
+  
+
+  ##
+  # Display methods on +klass+
+  # Returns a hash mapping method name to method contents (HACK?)
+
+  def display_class_method_list(klass)
+    method_map = {}
+
+    class_data = [
+                  :class_methods,
+                  :class_method_extensions,
+                  :instance_methods,
+                  :instance_method_extensions,
+                 ]
+    
+    class_data.each do |data_type|
+      data = klass.send data_type
+      
+      unless data.nil? or data.empty? then
+        @formatter.blankline
+        
+        heading = data_type.to_s.split('_').join(' ').capitalize << ':'
+        @formatter.display_heading heading, 2, ''
+        
+        method_names = []
+        data.each do |item|
+          method_names << item.name
+
+          if(data_type == :class_methods ||
+             data_type == :class_method_extensions) then
+            method_map["::#{item.name}"] = :class
+            method_map[item.name] = :class
+          else
+            #
+            # Since we iterate over instance methods after class methods,
+            # an instance method always will overwrite the unqualified
+            # class method entry for a class method of the same name.
+            #
+            method_map["##{item.name}"] = :instance
+            method_map[item.name] = :instance
+          end
+        end
+        method_names.sort!
+
+        @formatter.wrap method_names.join(',')
+      end
+    end
+
+    method_map
+  end
+  private :display_class_method_list
 
   ##
   # Display an Array of RDoc::Markup::Flow objects, +flow+.
@@ -172,10 +262,42 @@ class RDoc::RI::DefaultDisplay
   def display_method_list(methods)
     page do
       @formatter.wrap "More than one method matched your request.  You can refine your search by asking for information on one of:"
+      @formatter.blankline
+
+      methods.each do |method|
+        @formatter.raw_print_line "#{method.full_name} [#{method.source_path}]\n"
+      end
+    end
+  end
+  
+  ##
+  # Display a list of +methods+ and allow the user to select one of them.
 
+  def display_method_list_choice(methods)
+    page do
+      @formatter.wrap "More than one method matched your request.  Please choose one of the possible matches."
       @formatter.blankline
 
-      @formatter.wrap methods.map { |m| m.full_name }.join(", ")
+      methods.each_with_index do |method, index|
+        @formatter.raw_print_line "%3d %s [%s]\n" % [index + 1, method.full_name, method.source_path]
+      end
+      
+      @formatter.raw_print_line ">> "
+      
+      choice = $stdin.gets.strip!
+
+      if(choice == '')
+        return
+      end
+
+      choice = choice.to_i
+
+      if ((choice == 0) || (choice > methods.size)) then
+        @formatter.raw_print_line "Invalid choice!\n"
+      else
+        method = methods[choice - 1] 
+        display_method_info(method)
+      end
     end
   end
 
@@ -198,10 +320,8 @@ class RDoc::RI::DefaultDisplay
       @formatter.break_to_newline
     end
 
-    if method.source_path then
-      @formatter.blankline
-      @formatter.wrap("Extension from #{method.source_path}")
-    end
+    @formatter.blankline
+    @formatter.wrap("From #{method.source_path}")
   end
 
   ##