yard 0.6.4 → 0.6.5

data/lib/yard/registry_store.rb

@@ -137,8 +137,14 @@ module YARD
         @serializer = Serializers::YardocSerializer.new(@file)
       end
       destroy unless merge
-      values(false).each do |object|
-        @serializer.serialize(object)
+      
+      sdb = Registry.single_object_db
+      if sdb == true || (sdb == nil && keys.size < 3000)
+        @serializer.serialize(@store)
+      else
+        values(false).each do |object|
+          @serializer.serialize(object)
+        end
       end
       write_proxy_types
       write_checksums
@@ -197,12 +203,12 @@ module YARD
       end
     end
     
+    private
+
     def load_yardoc_old
       @store, @proxy_types = *Marshal.load(File.read_binary(@file))
     end
     
-    private
-    
     def load_proxy_types
       return unless File.file?(proxy_types_path)
       @proxy_types = Marshal.load(File.read_binary(proxy_types_path))
@@ -218,7 +224,14 @@ module YARD
     
     def load_root
       if root = @serializer.deserialize('root')
-        @store[:root] = root
+        @loaded_objects += 1
+        if root.is_a?(Hash) # single object db
+          log.debug "Loading single object DB from .yardoc"
+          @loaded_objects += (root.keys.size - 1)
+          @store = root
+        else # just the root object
+          @store[:root] = root
+        end
       end
     end
 

data/lib/yard/rubygems/doc_manager.rb

@@ -0,0 +1,75 @@
+require 'rubygems/doc_manager'
+
+class Gem::DocManager
+  def self.load_yardoc
+    require File.dirname(__FILE__) + '/../../yard'
+  end
+
+  def run_yardoc(*args)
+    args << '--quiet'
+    args << @spec.require_paths
+    if @spec.extra_rdoc_files.size > 0
+      args << '-'
+      args += @spec.extra_rdoc_files
+    end
+    args = args.flatten.map {|arg| arg.to_s }
+
+    old_pwd = Dir.pwd
+    Dir.chdir(@spec.full_gem_path)
+    YARD::CLI::Yardoc.run(*args)
+  rescue Errno::EACCES => e
+    dirname = File.dirname e.message.split("-")[1].strip
+    raise Gem::FilePermissionError.new(dirname)
+  rescue => ex
+    alert_error "While generating documentation for #{@spec.full_name}"
+    ui.errs.puts "... MESSAGE:   #{ex}"
+    ui.errs.puts "... YARDDOC args: #{args.join(' ')}"
+    ui.errs.puts "\t#{ex.backtrace.join("\n\t")}" if Gem.configuration.backtrace
+    ui.errs.puts "(continuing with the rest of the installation)"
+  ensure
+    Dir.chdir(old_pwd)
+  end
+
+  undef setup_rdoc
+  def setup_rdoc
+    if File.exist?(@doc_dir) && !File.writable?(@doc_dir) then
+      raise Gem::FilePermissionError.new(@doc_dir)
+    end
+
+    FileUtils.mkdir_p @doc_dir unless File.exist?(@doc_dir)
+
+    self.class.load_rdoc if @spec.has_rdoc?
+    self.class.load_yardoc if @spec.has_yardoc?
+  end
+
+  def install_yardoc
+    rdoc_dir = File.join(@doc_dir, 'rdoc')
+
+    FileUtils.rm_rf rdoc_dir
+
+    say "Installing YARD documentation for #{@spec.full_name}..."
+    run_yardoc '-o', rdoc_dir
+  end
+
+  def install_ri_yard
+    install_ri_yard_orig if @spec.has_rdoc?
+    return if @spec.has_rdoc? == false
+    return if @spec.has_yardoc?
+
+    self.class.load_yardoc
+    say "Building YARD (yri) index for #{@spec.full_name}..."
+    run_yardoc '-c', '-n'
+  end
+  alias install_ri_yard_orig install_ri
+  alias install_ri install_ri_yard
+
+  def install_rdoc_yard
+    if @spec.has_rdoc?
+      install_rdoc_yard_orig
+    elsif @spec.has_yardoc?
+      install_yardoc
+    end
+  end
+  alias install_rdoc_yard_orig install_rdoc
+  alias install_rdoc install_rdoc_yard
+end

data/lib/yard/rubygems/specification.rb

@@ -0,0 +1,23 @@
+require 'rubygems/specification'
+
+class Gem::Specification
+  # has_rdoc should not be ignored!
+  overwrite_accessor(:has_rdoc) { @has_rdoc }
+  overwrite_accessor(:has_rdoc=) {|v| @has_rdoc = v }
+
+  # @since 0.5.3
+  def has_yardoc=(value)
+    @has_rdoc = 'yard'
+  end
+
+  def has_yardoc
+    @has_rdoc == 'yard'
+  end
+
+  undef has_rdoc?
+  def has_rdoc?
+    @has_rdoc && @has_rdoc != 'yard'
+  end
+
+  alias has_yardoc? has_yardoc
+end

data/lib/yard/serializers/process_serializer.rb

@@ -13,7 +13,7 @@ module YARD
         @cmd = cmd
       end
       
-      # Overrides serialize behavour and writes data to standard input
+      # Overrides serialize behaviour and writes data to standard input
       # of the associated command
       def serialize(object, data)
         IO.popen(@cmd, 'w') {|io| io.write(data) }

data/lib/yard/serializers/yardoc_serializer.rb

@@ -61,7 +61,11 @@ module YARD
       end
       
       def serialize(object)
-        super(object, dump(object))
+        if Hash === object
+          super(object[:root], dump(object)) if object[:root]
+        else
+          super(object, dump(object))
+        end
       end
       
       def deserialize(path, is_path = false)
@@ -78,7 +82,8 @@ module YARD
       private
       
       def dump(object)
-        Marshal.dump(internal_dump(object, true))
+        object = internal_dump(object, true) unless object.is_a?(Hash)
+        Marshal.dump(object)
       end
       
       def internal_dump(object, first_object = false)

data/lib/yard/server/commands/display_object_command.rb

@@ -1,7 +1,7 @@
 module YARD
   module Server
     module Commands
-      # Displays documentation for a specific object identiied by the path
+      # Displays documentation for a specific object identified by the path
       class DisplayObjectCommand < LibraryCommand
         def run
           return index if path.empty?

data/lib/yard/server/commands/library_command.rb

@@ -76,13 +76,13 @@ module YARD
 
         def load_yardoc
           raise LibraryNotPreparedError unless library.yardoc_file
-          if @@last_yardoc == library.yardoc_file
+          if Thread.current[:__yard_last_yardoc__] == library.yardoc_file
             log.debug "Reusing yardoc file: #{library.yardoc_file}"
             return
           end
           Registry.clear
           Registry.load_yardoc(library.yardoc_file)
-          @@last_yardoc = library.yardoc_file
+          Thread.current[:__yard_last_yardoc__] = library.yardoc_file
         end
         
         def not_prepared

data/lib/yard/tags/default_factory.rb

@@ -10,7 +10,7 @@ module YARD
       # @param [String] text   the raw tag text
       # @return [Tag]          a tag object with the tag_name and text values filled
       def parse_tag(tag_name, text)
-        Tag.new(tag_name, text)
+        Tag.new(tag_name, text.strip)
       end
       
       # Parses tag text and creates a new tag with a key name and descriptive text

data/lib/yard/tags/library.rb

@@ -9,8 +9,8 @@ module YARD
     # be auto expanded into ruby code similar to what is shown in method #2. If you
     # do not provide a factory method to use, it will default to {DefaultFactory#parse_tag}
     # Example:
-    #   define_tag :param, :with_types_and_name
-    #   define_tag :author
+    #   define_tag "Parameter", :param, :with_types_and_name
+    #   define_tag "Author", :author
     #
     # The first line will expand to the code:
     #   def param_tag(text) tag_factory.parse_tag_with_types_and_name(text) end

data/lib/yard/templates/helpers/base_helper.rb

@@ -50,12 +50,21 @@ module YARD::Templates::Helpers
         case args.first
         when %r{://}, /^mailto:/
           link_url(args[0], args[1], {:target => '_parent'}.merge(args[2]||{}))
+        when /^include:file:(\S+)/
+          file = $1
+          if File.file?(file)
+            link_include_file(file)
+          else
+            log.warn "Cannot find file at `#{file}' for inclusion"
+            ""
+          end
         when /^include:(\S+)/
           path = $1
           if obj = YARD::Registry.resolve(object.namespace, path)
             link_include_object(obj)
           else
             log.warn "Cannot find object at `#{path}' for inclusion"
+            ""
           end
         when /^file:(\S+?)(?:#(\S+))?$/
           link_file($1, args[1] ? args[1] : $1, $2)
@@ -69,9 +78,19 @@ module YARD::Templates::Helpers
     
     # Includes an object's docstring into output.
     # @since 0.6.0
+    # @param [CodeObjects::Base] object the object to include
+    # @return [String] the object's docstring (no tags)
     def link_include_object(object)
       object.docstring
     end
+    
+    # Include a file as a docstring in output
+    # @since 0.7.0
+    # @param [String] file the filename to include
+    # @return [String] the file's contents
+    def link_include_file(file)
+      File.read(file)
+    end
 
     # Links to an object with an optional title
     # 

data/lib/yard/templates/helpers/html_helper.rb

@@ -7,8 +7,6 @@ module YARD
       include MarkupHelper
       include HtmlSyntaxHighlightHelper
       
-      SimpleMarkupHtml = RDoc::Markup::ToHtml.new rescue SM::ToHtml.new
-    
       # @group Escaping Template Data
     
       # Escapes HTML entities
@@ -80,8 +78,8 @@ module YARD
       # @since 0.6.0
       def html_markup_rdoc(text)
         begin
-          SimpleMarkupHtml.instance_variable_set("@from_path", url_for(object))
-          html = MarkupHelper::SimpleMarkup.convert(text, SimpleMarkupHtml)
+          simple_markup_html.instance_variable_set("@from_path", url_for(object))
+          html = markup_class(:rdoc).new.convert(text, simple_markup_html)
         end
 
         html = fix_dash_dash(html)
@@ -113,11 +111,11 @@ module YARD
       # 
       # @todo Refactor into own SimpleMarkup subclass
       def fix_typewriter(text)
-        text.gsub(/\+(?! )([^\n\+]{1,900})(?! )\+/) do
-          type_text, pre_text, no_match = $1, $`, $&
-          pre_match = pre_text.scan(%r(</?(?:pre|tt|code).*?>))
-          if pre_match.last.nil? || pre_match.last.include?('/')
-            '<tt>' + h(type_text) + '</tt>'
+        text.gsub(/(\s|^|>)\+(?! )([^\n\+]{1,900})(?! )\+/) do
+          first_text, type_text, pre_text, no_match = $1, $2, $`, $&
+          pre_match = (pre_text+first_text).scan(%r(</?(?:(?:pre|tt|code).*?>|[^>]+)\Z))
+          if pre_match.last.nil? || pre_match.last[1,1] == '/'
+            first_text + '<tt>' + h(type_text) + '</tt>'
           else
             no_match
           end
@@ -448,6 +446,21 @@ module YARD
       
       private
       
+      # Gets the SimpleMarkup class for the local thread
+      # 
+      # @return [RDoc::Markup::ToHtml] if RDoc 2.x is loaded
+      # @return [SM::ToHtml] if RDoc 1.x is loaded
+      # @since 0.6.5
+      def simple_markup_html
+        begin
+          require 'rdoc/markup/to_html'
+        rescue LoadError
+          require 'rdoc/markup/simple_markup/to_html' 
+        end
+        Thread.current[:__yard_simple_markup_html__] ||= 
+          (RDoc::Markup::ToHtml.new rescue SM::ToHtml.new)
+      end
+      
       # Converts a set of hash options into HTML attributes for a tag
       # 
       # @param [Hash{String => String}] opts the tag options

data/lib/yard/templates/helpers/html_syntax_highlight_helper.rb

@@ -7,6 +7,16 @@ module YARD
         # @param [String] source the Ruby source code
         # @return [String] the highlighted Ruby source
         def html_syntax_highlight_ruby(source)
+          if Parser::SourceParser.parser_type == :ruby
+            html_syntax_highlight_ruby_ripper(source)
+          else
+            html_syntax_highlight_ruby_legacy(source)
+          end
+        end
+        
+        private
+        
+        def html_syntax_highlight_ruby_ripper(source)
           tokenlist = Parser::Ruby::RubyParser.parse(source, "(syntax_highlight)").tokens
           output = ""
           tokenlist.each do |s|
@@ -25,6 +35,24 @@ module YARD
         rescue Parser::ParserSyntaxError
           h(source)
         end
+        
+        def html_syntax_highlight_ruby_legacy(source)
+          tokenlist = Parser::Ruby::Legacy::TokenList.new(source)
+          tokenlist.map do |s| 
+            prettyclass = s.class.class_name.sub(/^Tk/, '').downcase
+            prettysuper = s.class.superclass.class_name.sub(/^Tk/, '').downcase
+
+            case s
+            when Parser::Ruby::Legacy::RubyToken::TkWhitespace, Parser::Ruby::Legacy::RubyToken::TkUnknownChar
+              h s.text
+            when Parser::Ruby::Legacy::RubyToken::TkId
+              prettyval = h(s.text)
+              "<span class='#{prettyval} #{prettyclass} #{prettysuper}'>#{prettyval}</span>"
+            else
+              "<span class='#{prettyclass} #{prettysuper}'>#{h s.text}</span>"
+            end
+          end.join
+        end
       end
     end
   end

data/lib/yard/templates/helpers/markup_helper.rb

@@ -23,15 +23,18 @@ module YARD
       MARKUP_PROVIDERS = {
         :markdown => [
           {:lib => :bluecloth, :const => 'BlueCloth'},
+          {:lib => :kramdown, :const => "Kramdown::Document"},
           {:lib => :maruku, :const => 'Maruku'},
           {:lib => :"rpeg-markdown", :const => "PEGMarkdown"},
-          {:lib => :rdiscount, :const => "RDiscount"},
-          {:lib => :kramdown, :const => "Kramdown::Document"}
+          {:lib => :rdiscount, :const => "RDiscount"}
         ],
         :textile => [
           {:lib => :redcloth, :const => 'RedCloth'}
         ],
-        :rdoc => [],
+        :rdoc => [
+          {:lib => 'rdoc/markup', :const => 'RDoc::Markup'},
+          {:lib => 'rdoc/markup/simple_markup', :const => 'SM::SimpleMarkup'}
+        ],
         :text => [],
         :html => []
       }
@@ -52,32 +55,19 @@ module YARD
       # files to detect the markup type.
       MARKUP_FILE_SHEBANG = /\A#!(\S+)\s*$/
 
-      begin
-        require 'rdoc/markup'
-        require 'rdoc/markup/to_html'
-        SimpleMarkup = RDoc::Markup.new
-      rescue Gem::LoadError
-        raise
-      rescue LoadError
-        require 'rubygems'
-        require 'rdoc/markup/simple_markup'
-        require 'rdoc/markup/simple_markup/to_html'
-        SimpleMarkup = SM::SimpleMarkup.new
-      end
-      
       # Attempts to load the first valid markup provider in {MARKUP_PROVIDERS}.
       # If a provider is specified, immediately try to load it.
       # 
       # On success this sets `@markup_provider` and `@markup_class` to
       # the provider name and library constant class/module respectively for
-      # the loaded proider.
+      # the loaded provider.
       # 
       # On failure this method will inform the user that no provider could be
       # found and exit the program.
       # 
       # @return [Boolean] whether the markup provider was successfully loaded.
       def load_markup_provider(type = options[:markup])
-        return true if type == :rdoc || MarkupHelper.markup_cache[type]
+        return true if MarkupHelper.markup_cache[type]
         MarkupHelper.markup_cache[type] ||= {}
         
         providers = MARKUP_PROVIDERS[type]
@@ -87,15 +77,17 @@ module YARD
         end
         
         if providers == nil || providers.empty?
-          log.error "Invalid markup type '#{type}' or markup provider is not registered."
+          log.error "Invalid markup type '#{type}' or markup provider " +
+            "(#{options[:markup_provider]}) is not registered."
           return false
         end
         
         # Search for provider, return the library class name as const if found
         providers.each do |provider|
           begin require provider[:lib].to_s; rescue LoadError; next end
+          begin klass = eval("::" + provider[:const]); rescue NameError; next end
           MarkupHelper.markup_cache[type][:provider] = provider[:lib] # Cache the provider
-          MarkupHelper.markup_cache[type][:class] = eval("::" + provider[:const])
+          MarkupHelper.markup_cache[type][:class] = klass
           return true
         end
         
@@ -145,7 +137,7 @@ module YARD
       # @param [Symbol] the markup type (:rdoc, :markdown, etc.)
       # @return [Class] the markup class
       def markup_class(type = options[:markup])
-        type == :rdoc ? SimpleMarkup : MarkupHelper.markup_cache[type][:class]
+        MarkupHelper.markup_cache[type][:class]
       end
       
       # Gets the markup provider name for a markup type
@@ -154,7 +146,7 @@ module YARD
       # @param [Symbol] the markup type (:rdoc, :markdown, etc.)
       # @return [Symbol] the markup provider name (usually the gem name of the library)
       def markup_provider(type = options[:markup])
-        type == :rdoc ? nil : MarkupHelper.markup_cache[type][:provider]
+        MarkupHelper.markup_cache[type][:provider]
       end
     end
   end