rdoc 4.0.0.preview2.1 → 4.0.0.rc.2

data/lib/rdoc/markup/to_markdown.rb

@@ -18,6 +18,9 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
     @headings[5] = ['##### ',  '']
     @headings[6] = ['###### ', '']
 
+    add_special_RDOCLINK
+    add_special_TIDYLINK
+
     @hard_break = "  \n"
   end
 
@@ -130,5 +133,57 @@ class RDoc::Markup::ToMarkdown < RDoc::Markup::ToRdoc
     @res << "\n" unless @res =~ /\n\z/
   end
 
+  ##
+  # Creates a Markdown-style URL from +url+ with +text+.
+
+  def gen_url url, text
+    scheme, url, = parse_url url
+
+    "[#{text.sub(%r{^#{scheme}:/*}i, '')}](#{url})"
+  end
+
+  ##
+  # Handles <tt>rdoc-</tt> type links for footnotes.
+
+  def handle_rdoc_link url
+    case url
+    when /\Ardoc-ref:/ then
+      $'
+    when /\Ardoc-label:footmark-(\d+)/ then
+      "[^#{$1}]:"
+    when /\Ardoc-label:foottext-(\d+)/ then
+      "[^#{$1}]"
+    when /\Ardoc-label:label-/ then
+      gen_url url, $'
+    when /\Ardoc-[a-z]+:/ then
+      $'
+    end
+  end
+
+  ##
+  # Converts the RDoc markup tidylink into a Markdown.style link.
+
+  def handle_special_TIDYLINK special
+    text = special.text
+
+    return text unless text =~ /\{(.*?)\}\[(.*?)\]/ or text =~ /(\S+)\[(.*?)\]/
+
+    label = $1
+    url   = $2
+
+    if url =~ /^rdoc-label:foot/ then
+      handle_rdoc_link url
+    else
+      gen_url url, label
+    end
+  end
+
+  ##
+  # Converts the rdoc-...: links into a Markdown.style links.
+
+  def handle_special_RDOCLINK special
+    handle_rdoc_link special.text
+  end
+
 end
 

data/lib/rdoc/parser.rb

@@ -45,6 +45,11 @@ class RDoc::Parser
 
   end
 
+  ##
+  # The name of the file being parsed
+
+  attr_reader :file_name
+
   ##
   # Alias an extension to another extension. After this call, files ending
   # "new_ext" will be parsed using the same parser as "old_ext"
@@ -53,7 +58,7 @@ class RDoc::Parser
     old_ext = old_ext.sub(/^\.(.*)/, '\1')
     new_ext = new_ext.sub(/^\.(.*)/, '\1')
 
-    parser = can_parse "xxx.#{old_ext}"
+    parser = can_parse_by_name "xxx.#{old_ext}"
     return false unless parser
 
     RDoc::Parser.parsers.unshift [/\.#{new_ext}$/, parser]
@@ -72,14 +77,14 @@ class RDoc::Parser
 
     have_encoding = s.respond_to? :encoding
 
-    if have_encoding then
-      return false if s.encoding != Encoding::ASCII_8BIT and s.valid_encoding?
-    end
-
     return true if s[0, 2] == Marshal.dump('')[0, 2] or s.index("\x00")
 
     if have_encoding then
-      s.force_encoding Encoding.default_external
+      mode = "r"
+      s.sub!(/\A#!.*\n/, '')     # assume shebang line isn't longer than 1024.
+      encoding = s[/^\s*\#\s*(?:-\*-\s*)?(?:en)?coding:\s*([^\s;]+?)(?:-\*-|[\s;])/, 1]
+      mode = "r:#{encoding}" if encoding
+      s = File.open(file, mode) {|f| f.gets(nil, 1024)}
 
       not s.valid_encoding?
     else
@@ -126,23 +131,36 @@ class RDoc::Parser
     zip_signature == "PK\x03\x04" or
       zip_signature == "PK\x05\x06" or
       zip_signature == "PK\x07\x08"
+  rescue
+    false
   end
 
   ##
   # Return a parser that can handle a particular extension
 
-  def self.can_parse(file_name)
-    parser = RDoc::Parser.parsers.find { |regexp,| regexp =~ file_name }.last
+  def self.can_parse file_name
+    parser = can_parse_by_name file_name
 
     # HACK Selenium hides a jar file using a .txt extension
     return if parser == RDoc::Parser::Simple and zip? file_name
 
+    parser
+  end
+
+  ##
+  # Returns a parser that can handle the extension for +file_name+.  This does
+  # not depend upon the file being readable.
+
+  def self.can_parse_by_name file_name
+    _, parser = RDoc::Parser.parsers.find { |regexp,| regexp =~ file_name }
+
     # The default parser must not parse binary files
     ext_name = File.extname file_name
     return parser if ext_name.empty?
+
     if parser == RDoc::Parser::Simple and ext_name !~ /txt|rdoc/ then
       case check_modeline file_name
-      when 'rdoc' then # continue
+      when nil, 'rdoc' then # continue
       else return nil
       end
     end
@@ -168,6 +186,8 @@ class RDoc::Parser
       type = $1
     end
 
+    return nil if /coding:/i =~ type
+
     type.downcase
   rescue ArgumentError # invalid byte sequence, etc.
   end
@@ -182,21 +202,25 @@ class RDoc::Parser
     parser = use_markup content
 
     unless parser then
+      parse_name = file_name
+
       # If no extension, look for shebang
       if file_name !~ /\.\w+$/ && content =~ %r{\A#!(.+)} then
         shebang = $1
         case shebang
         when %r{env\s+ruby}, %r{/ruby}
-          file_name = "dummy.rb"
+          parse_name = 'dummy.rb'
         end
       end
 
-      parser = can_parse file_name
+      parser = can_parse parse_name
     end
 
     return unless parser
 
     parser.new top_level, file_name, content, options, stats
+  rescue SystemCallError
+    nil
   end
 
   ##

data/lib/rdoc/parser/changelog.rb

@@ -102,7 +102,12 @@ class RDoc::Parser::ChangeLog < RDoc::Parser
 
   def group_entries entries
     entries.group_by do |title, _|
-      Time.parse(title).strftime "%Y-%m-%d"
+      begin
+        Time.parse(title).strftime '%Y-%m-%d'
+      rescue NoMethodError, ArgumentError
+        time, = title.split '  ', 2
+        Time.parse(time).strftime '%Y-%m-%d'
+      end
     end
   end
 
@@ -139,6 +144,9 @@ class RDoc::Parser::ChangeLog < RDoc::Parser
           time = Time.parse entry_name
           # HACK Ruby 1.8 does not raise ArgumentError for Time.parse "Other"
           entry_name = nil unless entry_name =~ /#{time.year}/
+        rescue NoMethodError
+          time, = entry_name.split '  ', 2
+          time = Time.parse time
         rescue ArgumentError
           entry_name = nil
         end

data/lib/rdoc/parser/ruby.rb

@@ -1116,6 +1116,18 @@ class RDoc::Parser::Ruby < RDoc::Parser
           name = name_t2.name
           prev_container = container
           container = container.find_module_named(name_t.name)
+
+          unless container then
+            constant = prev_container.constants.find do |const|
+              const.name == name_t.name
+            end
+
+            if constant then
+              parse_method_dummy prev_container
+              return
+            end
+          end
+
           unless container then
             added_container = true
             obj = name_t.name.split("::").inject(Object) do |state, item|
@@ -1138,10 +1150,7 @@ class RDoc::Parser::Ruby < RDoc::Parser
             container.record_location @top_level
           end
         when TkIDENTIFIER, TkIVAR, TkGVAR then
-          dummy = RDoc::Context.new
-          dummy.parent = container
-          dummy.store  = container.store
-          skip_method dummy
+          parse_method_dummy container
           return
         when TkTRUE, TkFALSE, TkNIL then
           klass_name = "#{name_t.name.capitalize}Class"
@@ -1228,6 +1237,16 @@ class RDoc::Parser::Ruby < RDoc::Parser
     @stats.add_method meth
   end
 
+  ##
+  # Parses a method that needs to be ignored.
+
+  def parse_method_dummy container
+    dummy = RDoc::Context.new
+    dummy.parent = container
+    dummy.store  = container.store
+    skip_method dummy
+  end
+
   ##
   # Extracts +yield+ parameters from +method+
 

data/lib/rdoc/rd/block_parser.rb

@@ -394,11 +394,12 @@ end
 # Adds footnote +content+ to the document
 
 def add_footnote content
-  index = @footnotes.length + 1
+  index = @footnotes.length / 2 + 1
 
   footmark_link = "{^#{index}}[rdoc-label:footmark-#{index}:foottext-#{index}]"
 
-  @footnotes << RDoc::Markup::Paragraph.new(footmark_link, *content)
+  @footnotes << RDoc::Markup::Paragraph.new(footmark_link, ' ', *content)
+  @footnotes << RDoc::Markup::BlankLine.new
 
   index
 end

data/lib/rdoc/rd/block_parser.ry

@@ -607,11 +607,12 @@ end
 # Adds footnote +content+ to the document
 
 def add_footnote content
-  index = @footnotes.length + 1
+  index = @footnotes.length / 2 + 1
 
   footmark_link = "{^#{index}}[rdoc-label:footmark-#{index}:foottext-#{index}]"
 
-  @footnotes << RDoc::Markup::Paragraph.new(footmark_link, *content)
+  @footnotes << RDoc::Markup::Paragraph.new(footmark_link, ' ', *content)
+  @footnotes << RDoc::Markup::BlankLine.new
 
   index
 end

data/lib/rdoc/rd/inline_parser.rb

@@ -1104,7 +1104,7 @@ def _reduce_101(val, _values, result)
 end
 
 def _reduce_102(val, _values, result)
-      result = "<tt>#{val[1]}</tt>"
+      result = inline "<tt>#{val[1]}</tt>", val[1]
     
     result
 end

data/lib/rdoc/rd/inline_parser.ry

@@ -293,7 +293,7 @@ class InlineParser
     ;
 
     verb : VERB_OPEN verb_strings VERB_CLOSE {
-      result = "<tt>#{val[1]}</tt>"
+      result = inline "<tt>#{val[1]}</tt>", val[1]
     }
     ;
 

data/lib/rdoc/ruby_lex.rb

@@ -982,12 +982,13 @@ class RDoc::RubyLex
       indent = true
     end
     if /['"`]/ =~ ch
-      lt = ch
+      user_quote = lt = ch
       quoted = ""
       while (c = getc) && c != lt
         quoted.concat c
       end
     else
+      user_quote = nil
       lt = '"'
       quoted = ch.dup
       while (c = getc) && c =~ /\w/
@@ -1007,8 +1008,17 @@ class RDoc::RubyLex
       end
     end
 
+    output_heredoc = reserve.join =~ /\A\r?\n\z/
+
+    if output_heredoc then
+      doc = '<<'
+      doc << '-' if indent
+      doc << "#{user_quote}#{quoted}#{user_quote}\n"
+    else
+      doc = '"'
+    end
+
     @here_header = false
-    doc = '"'
     while l = gets
       l = l.sub(/(:?\r)?\n\z/, "\n")
       if (indent ? l.strip : l.chomp) == quoted
@@ -1016,7 +1026,12 @@ class RDoc::RubyLex
       end
       doc << l
     end
-    doc << '"'
+
+    if output_heredoc then
+      doc << l.chomp
+    else
+      doc << '"'
+    end
 
     @here_header = true
     @here_readed.concat reserve
@@ -1024,9 +1039,10 @@ class RDoc::RubyLex
       ungetc ch
     end
 
+    token_class = output_heredoc ? RDoc::RubyLex::TkHEREDOC : Ltype2Token[lt]
     @ltype = ltback
     @lex_state = EXPR_END
-    Token(Ltype2Token[lt], doc)
+    Token(token_class, doc)
   end
 
   def identify_quotation

data/lib/rdoc/ruby_token.rb

@@ -331,6 +331,7 @@ module RDoc::RubyToken
     [:TkINTEGER,    TkVal],
     [:TkFLOAT,      TkVal],
     [:TkSTRING,     TkVal],
+    [:TkHEREDOC,    TkVal],
     [:TkXSTRING,    TkVal],
     [:TkREGEXP,     TkVal],
     [:TkSYMBOL,     TkVal],

data/lib/rdoc/servlet.rb

@@ -326,21 +326,25 @@ version.  If you're viewing Ruby's documentation, include the version of ruby.
 
       search_index << name
 
-      comment = case type
-                when :gem
-                  gemspec = path.gsub(%r%/doc/([^/]*?)/ri$%,
-                                      '/specifications/\1.gemspec')
-
-                  spec = Gem::Specification.load gemspec
-
-                  spec.summary
-                when :system then
-                  'Documentation for the Ruby standard library'
-                when :site then
-                  'Documentation for non-gem libraries'
-                when :home then
-                  'Documentation from your home directory'
-                end
+      case type
+      when :gem
+        gemspec = path.gsub(%r%/doc/([^/]*?)/ri$%,
+                            '/specifications/\1.gemspec')
+
+        spec = Gem::Specification.load gemspec
+
+        path    = spec.full_name
+        comment = spec.summary
+      when :system then
+        path    = 'ruby'
+        comment = 'Documentation for the Ruby standard library'
+      when :site then
+        path    = 'site'
+        comment = 'Documentation for non-gem libraries'
+      when :home then
+        path    = 'home'
+        comment = 'Documentation from your home directory'
+      end
 
       info << [name, '', path, '', comment]
     end
@@ -387,8 +391,12 @@ version.  If you're viewing Ruby's documentation, include the version of ruby.
 
   def store_for source_name
     case source_name
+    when 'home' then
+      RDoc::Store.new RDoc::RI::Paths.home_dir, :home
     when 'ruby' then
       RDoc::Store.new RDoc::RI::Paths.system_dir, :system
+    when 'site' then
+      RDoc::Store.new RDoc::RI::Paths.site_dir, :site
     else
       ri_dir, type = ri_paths.find do |dir, dir_type|
         next unless dir_type == :gem
@@ -396,7 +404,8 @@ version.  If you're viewing Ruby's documentation, include the version of ruby.
         source_name == dir[%r%/([^/]*)/ri$%, 1]
       end
 
-      raise "could not find ri documentation for #{source_name}" unless
+      raise RDoc::Error,
+            "could not find ri documentation for #{source_name}" unless
         ri_dir
 
       RDoc::Store.new ri_dir, type

data/lib/rdoc/store.rb

@@ -354,6 +354,9 @@ class RDoc::Store
         loaded_mod = load_class_data name
 
         file = loaded_mod.in_files.first
+
+        return unless file # legacy data source
+
         file.store = self
 
         mod = file.add_module RDoc::NormalModule, name
@@ -816,13 +819,13 @@ class RDoc::Store
     @cache[:ancestors][full_name] ||= []
     @cache[:ancestors][full_name].concat ancestors
 
-    attributes = klass.attributes.map do |attribute|
+    attribute_definitions = klass.attributes.map do |attribute|
       "#{attribute.definition} #{attribute.name}"
     end
 
-    unless attributes.empty? then
+    unless attribute_definitions.empty? then
       @cache[:attributes][full_name] ||= []
-      @cache[:attributes][full_name].concat attributes
+      @cache[:attributes][full_name].concat attribute_definitions
     end
 
     to_delete = []
@@ -836,13 +839,15 @@ class RDoc::Store
 
       class_methods    = class_methods.   map { |method| method.name }
       instance_methods = instance_methods.map { |method| method.name }
+      attribute_names  = klass.attributes.map { |attr|   attr.name }
 
       old = @cache[:class_methods][full_name] - class_methods
       to_delete.concat old.map { |method|
         method_file full_name, "#{full_name}::#{method}"
       }
 
-      old = @cache[:instance_methods][full_name] - instance_methods
+      old = @cache[:instance_methods][full_name] -
+        instance_methods - attribute_names
       to_delete.concat old.map { |method|
         method_file full_name, "#{full_name}##{method}"
       }