yard 0.5.0 → 0.5.1p1

data/ChangeLog

@@ -1,3 +1,54 @@
+2009-12-16  Loren Segal <lsegal@soen.ca>
+
+  * ChangeLog, lib/yard.rb: Bump version to 0.5.1p1
+
+  * lib/yard/cli/yri.rb, lib/yard/core_ext/file.rb, lib/yard/registry_store.rb,
+  lib/yard/serializers/file_system_serializer.rb, spec/core_ext/file_spec.rb:
+  Ensure '~/.yard' path is created before writing certain config files.  - Adds
+  File.open! to ensure path exists before writing file  Closes gh-57
+
+  * lib/yard/registry_store.rb: Return true/false in RegistryStore#load!
+
+2009-12-15  Loren Segal <lsegal@soen.ca>
+
+  * docs/WhatsNew.md: Forgot to add version number for changes
+
+  * ChangeLog, README.md, lib/yard.rb, yard.gemspec: Bump version to 0.5.1
+
+  * docs/WhatsNew.md: Update What's New document
+
+  * lib/yard/cli/yri.rb, spec/cli/yri_spec.rb: Always put local directory's
+  .yardoc ahead of cache
+
+  * lib/yard/cli/yri.rb, spec/cli/yri_spec.rb: Allow user to specify
+  ~/.yard/yri_search_paths file listing extra yardoc dbs to search.  File
+  format should just be newline separated .yardoc files/directories: 
+  /path/to/.yardoc /path/to/other.yardoc ...
+
+  * lib/yard/cli/yardoc.rb: Improve behaviour of re-generating changed objects
+  during incremental parsing
+
+  * lib/yard/registry.rb, lib/yard/registry_store.rb,
+  spec/registry_store_spec.rb: Change behaviour of RegistryStore loading cache.
+  Does not load cache on #keys/#values by default. Instead use #load! or
+  #load_all to load all contents explicitly
+
+  * lib/yard/parser/source_parser.rb, spec/parser/source_parser_spec.rb: Change
+  behaviour of SourceParser logging
+
+  * lib/yard/registry_store.rb: Add cache for failed lookups
+
+  * lib/yard/parser/ruby/ruby_parser.rb, spec/parser/ruby/ruby_parser_spec.rb:
+  Fix RubyParser in 1.9.1p376 (ripper lib was changed)
+
+  * lib/yard/registry.rb, spec/registry_spec.rb: Add specs for
+  Registry.yardoc_file_for_gem
+
+  * lib/yard.rb, lib/yard/cli/yri.rb, lib/yard/registry.rb, spec/yard_spec.rb:
+  Add support for packages named yard-doc-* to be loaded by yri
+
+  * Rakefile: Should use RUBY_PLATFORM
+
 2009-12-14  Loren Segal <lsegal@soen.ca>
 
   * ChangeLog, README.md, docs/WhatsNew.md, lib/yard.rb, yard.gemspec: Bump

data/README.md

@@ -1,4 +1,4 @@
-YARD Release 0.5.0 "The Longest" (Dec 14th 2009)
+YARD Release 0.5.1 "The Longest" (Dec 15th 2009)
 ===================================================
 
 **Homepage**:  [http://yardoc.org](http://yardoc.org)   

data/Rakefile

@@ -2,7 +2,7 @@ require File.dirname(__FILE__) + '/lib/yard'
 require 'rubygems'
 require 'rake/gempackagetask'
 
-WINDOWS = (PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
+WINDOWS = (RUBY_PLATFORM =~ /win32|cygwin/ ? true : false) rescue false
 SUDO = WINDOWS ? '' : 'sudo'
 
 task :default => :specs

data/docs/WhatsNew.md

@@ -1,15 +1,17 @@
 What's New in 0.5.x?
 ====================
 
-1. **Support for documenting native Ruby C code**
-2. **Incremental parsing and output generation with `yardoc -c`**
-2. **Improved `yri` support to perform lookups on installed Gems**
-3. **Added `yardoc --default-return` and `yardoc --hide-void-return`**
-4. **Multiple syntax highlighting language support**
-5. **New .yardoc format**
-
-Support for documenting native Ruby C code
-------------------------------------------
+1. **Support for documenting native Ruby C code** (0.5.0)
+2. **Incremental parsing and output generation with `yardoc -c`** (0.5.0)
+2. **Improved `yri` support to perform lookups on installed Gems** (0.5.0)
+3. **Added `yardoc --default-return` and `yardoc --hide-void-return`** (0.5.0)
+4. **Multiple syntax highlighting language support** (0.5.0)
+5. **New .yardoc format** (0.5.0)
+6. **Support for yard-doc-* gem packages as hosted .yardoc dbs** (0.5.1)
+7. **Support for extra search paths in `yri`** (0.5.1)
+
+Support for documenting native Ruby C code (0.5.0)
+--------------------------------------------------
 
 It is now possible to document native Ruby extensions with YARD with a new
 C parser mostly borrowed from RDoc. This enables the ability to document
@@ -17,8 +19,8 @@ Ruby's core and stdlibs which will be hosted on http://yardoc.org/docs. In
 addition, the .yardoc dump for the Ruby-core classes will become available
 as an installable gem for yri support (see #3).
 
-Incremental parsing and output generation with `yardoc -c`
-----------------------------------------------------------
+Incremental parsing and output generation with `yardoc -c` (0.5.0)
+------------------------------------------------------------------
 
 YARD now compares file checksums before parsing when using `yardoc -c` 
 (aka `yardoc --use-cache`) to do incremental parsing of only the files that
@@ -29,8 +31,8 @@ remember that when using incremental output generation, the index will not
 be rebuilt and inter-file links might not hook up right, so it is best to
 perform a full rebuild at the end of such previews.
 
-Improved `yri` support to perform lookups on installed Gems
------------------------------------------------------------
+Improved `yri` support to perform lookups on installed Gems (0.5.0)
+-------------------------------------------------------------------
 
 The `yri` executable can now perform lookups on gems that have been parsed
 by yard. Therefore, to use this command you must first parse all gems with
@@ -51,8 +53,8 @@ You can now do lookups with yri:
 All lookups are cached to `~/.yard/yri_cache` for quicker lookups the second
 time onward.
 
-Added `yardoc --default-return` and `yardoc --hide-void-return`
----------------------------------------------------------------
+Added `yardoc --default-return` and `yardoc --hide-void-return` (0.5.0)
+-----------------------------------------------------------------------
 
 YARD defaults to displaying (Object) as the default return type of any
 method that has not declared a @return tag. To customize the default
@@ -65,8 +67,8 @@ You can also use the empty string to list no return type.
 In addition, you can use --hide-void-return to ignore any method that
 defines itself as a void type by: `@return [void]`
 
-Multiple syntax highlighting language support
----------------------------------------------
+Multiple syntax highlighting language support (0.5.0)
+-----------------------------------------------------
 
 YARD now supports the ability to specify a language type for code blocks in 
 docstrings. Although no actual highlighting support is added for any language
@@ -87,8 +89,8 @@ To use this language in code blocks, prefix the block with `!!!LANGNAME`:
 By the same token. you can now use `!!!plain` to ignore highlighting for
 a specific code block.
 
-New .yardoc format
-------------------
+New .yardoc format (0.5.0)
+--------------------------
 
 To make the above yri support possible, the .yardoc format was redesigned
 to be a directory instead of a file. YARD can still load old .yardoc files,
@@ -96,6 +98,32 @@ but they will be automatically upgraded if re-saved. The new .yardoc format
 does have a larger memory footprint, but this will hopefully be optimized
 downward.
 
+Support for yard-doc-* gem packages as hosted .yardoc dbs (0.5.1)
+-----------------------------------------------------------------
+
+You can now install special YARD plugin gems titled yard-doc-NAME to get
+packaged a .yardoc database. This will enable yri lookups or building docs
+for the gem without the code. 
+
+One main use for this is the `yard-doc-core` package, which enabled yri 
+support for Ruby core classes (stdlib coming soon as `yard-doc-stdlib`).
+To install it, simply:
+
+    $ sudo gem install yard-doc-core
+    # now you can use:
+    $ yri String
+
+This will by default install the 1.9.1 core library. To install a library
+for a specific version of Ruby, use the `--version` switch on gem:
+
+    $ sudo gem install --version '= 1.8.6' yard-doc-core
+
+Support for extra search paths in `yri` (0.5.1)
+-----------------------------------------------
+
+You can now add custom paths to non-gem .yardoc files 
+by adding them as newline separated paths in `~/.yard/yri_search_paths`.
+
 
 What's New in 0.4.x?
 ====================

data/lib/yard.rb

@@ -1,5 +1,5 @@
 module YARD
-  VERSION = "0.5.0"
+  VERSION = "0.5.1p1"
   ROOT = File.dirname(__FILE__)
   TEMPLATE_ROOT = File.join(File.dirname(__FILE__), '..', 'templates')
   CONFIG_DIR = File.expand_path('~/.yard')
@@ -33,7 +33,7 @@ module YARD
     
     Gem.source_index.find_name('').each do |gem|
       begin
-        if gem.name =~ /^yard[-_]/ && !ignored_plugins.include?(gem.name)
+        if gem.name =~ /^yard[-_](?!doc-)/ && !ignored_plugins.include?(gem.name)
           log.debug "Loading plugin '#{gem.name}'..."
           require gem.name 
         end

data/lib/yard/cli/yardoc.rb

@@ -61,18 +61,16 @@ module YARD
         optparse(*yardopts)
         optparse(*args)
         
-        Registry.load if use_cache
+        if use_cache
+          Registry.load
+          checksums = Registry.checksums.dup
+        end
         YARD.parse(files)
         Registry.save(use_cache)
         
         if generate
           if use_cache
-            objects = all_objects
-            Registry.all # load all
-            objects.each do |object|
-              opts = options.merge(:object => object, :type => :layout)
-              Templates::Engine.render(opts)
-            end
+            generate_with_cache(checksums)
           else
             Templates::Engine.generate(all_objects, options)
           end
@@ -80,25 +78,13 @@ module YARD
         
         true
       end
-
+      
       # The list of all objects to process. Override this method to change
       # which objects YARD should generate documentation for.
       # 
       # @return [Array<CodeObjects::Base>] a list of code objects to process
       def all_objects
-        types = [:root, :module, :class]
-        if use_cache
-          Registry.paths(false).map do |path|
-            obj = Registry.at(path)
-            if types.include?(obj.type)
-              obj
-            else
-              nil
-            end
-          end.compact
-        else
-          Registry.all(*types)
-        end
+        Registry.all(:root, :module, :class)
       end
       
       # Parses the .yardopts file for default yard options
@@ -111,6 +97,23 @@ module YARD
       
       private
       
+      # Generates output for changed objects in cache
+      # @return [void]
+      def generate_with_cache(checksums)
+        changed_files = []
+        Registry.checksums.each do |file, hash|
+          changed_files << file if checksums[file] != hash
+        end
+        Registry.load_all
+        all_objects.each do |object|
+          if object.files.any? {|f, line| changed_files.include?(f) }
+            log.info "Re-generating object #{object.path}..."
+            opts = options.merge(:object => object, :type => :layout)
+            Templates::Engine.render(opts)
+          end
+        end
+      end
+
       # Reads a .document file in the directory to get source file globs
       # @return [void] 
       def support_rdoc_document_file!

data/lib/yard/cli/yri.rb

@@ -3,6 +3,7 @@ module YARD
     # A tool to view documentation in the console like `ri`
     class YRI < Base
       CACHE_FILE = File.expand_path('~/.yard/yri_cache')
+      SEARCH_PATHS_FILE = File.expand_path('~/.yard/yri_search_paths')
       
       # Helper method to run the utility on an instance.
       # @see #run
@@ -10,7 +11,8 @@ module YARD
         
       def initialize
         @cache = {}
-        @search_paths = [Registry.yardoc_file, YARD::ROOT + '/../.yardoc']
+        @search_paths = []
+        add_default_paths
         add_gem_paths
         load_cache
         @search_paths.uniq!
@@ -40,7 +42,7 @@ module YARD
         return if path == Registry.yardoc_file
         @cache[name] = path
         
-        File.open(CACHE_FILE, 'w') do |file|
+        File.open!(CACHE_FILE, 'w') do |file|
           @cache.each do |key, value|
             file.puts("#{key} #{value}")
           end
@@ -58,9 +60,11 @@ module YARD
       
       def find_object(name)
         @search_paths.unshift(@cache[name]) if @cache[name]
+        @search_paths.unshift(Registry.yardoc_file)
         
         log.debug "Searching for #{name} in search paths"
         @search_paths.each do |path|
+          next unless File.exist?(path)
           log.debug "Searching for #{name} in #{path}..."
           Registry.load(path)
           obj = Registry.at(name)
@@ -86,12 +90,23 @@ module YARD
         require 'rubygems'
         Gem.source_index.find_name('').each do |spec|
           if yfile = Registry.yardoc_file_for_gem(spec.name)
-            @search_paths << yfile
+            if spec.name =~ /^yard-doc-/
+              @search_paths.unshift(yfile)
+            else
+              @search_paths.push(yfile)
+            end
           end
         end
       rescue LoadError
       end
       
+      # Adds paths in {SEARCH_PATHS_FILE}
+      def add_default_paths
+        return unless File.file?(SEARCH_PATHS_FILE)
+        paths = File.readlines(SEARCH_PATHS_FILE).map {|l| l.strip }
+        @search_paths.push(*paths)
+      end
+      
       # Parses commandline options.
       # @param [Array<String>] args each tokenized argument
       def optparse(*args)

data/lib/yard/core_ext/file.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 class File
   RELATIVE_PARENTDIR = '..'
   RELATIVE_SAMEDIR = '.'
@@ -40,4 +42,11 @@ class File
     end
     File.join(*path)
   end
+  
+  # Forces opening a file (for writing) by first creating the file's directory
+  def self.open!(file, *args, &block)
+    dir = dirname(file)
+    FileUtils.mkdir_p(dir) unless directory?(dir)
+    open(file, *args, &block)
+  end
 end

data/lib/yard/parser/ruby/ruby_parser.rb

@@ -208,6 +208,7 @@ module YARD
         def on_body_stmt(*args)
           args.compact.size == 1 ? args.first : AstNode.new(:list, args)
         end
+        alias on_bodystmt on_body_stmt
         
         def on_assoc_new(*args)
           AstNode.new(:assoc, args)

data/lib/yard/parser/source_parser.rb

@@ -145,9 +145,10 @@ module YARD
           @file = content
           content = IO.read(content)
           checksum = Registry.checksum_for(content)
-          if Registry.checksums[file] == checksum
-            log.info "File '#{file}' hasn't changed, skipping..."
-            return
+          return if Registry.checksums[file] == checksum
+
+          if Registry.checksums.has_key?(file)
+            log.info "File '#{file}' was modified, re-processing..."
           end
           Registry.checksums[@file] = checksum
           self.parser_type = parser_type_for_filename(file)

data/lib/yard/registry.rb

@@ -48,7 +48,14 @@ module YARD
       # @return [nil] if +for_writing+ is set to false and no yardoc file
       #   is found, returns nil.
       def yardoc_file_for_gem(gem, ver_require = ">= 0", for_writing = false)
-        spec = Gem.source_index.find_name(gem, ver_require).first
+        spec = Gem.source_index.find_name(gem, ver_require)
+        return if spec.empty?
+        spec = spec.first
+        
+        if gem =~ /^yard-doc-/
+          path = File.join(spec.full_gem_path, DEFAULT_YARDOC_FILE)
+          return File.exist?(path) && !for_writing ? path : nil
+        end
         
         if for_writing
           global_yardoc_file(spec, for_writing) ||
@@ -136,6 +143,15 @@ module YARD
       @store.load(file)
     end
     
+    def load!(file = yardoc_file)
+      clear
+      @store.load!(file)
+    end
+    
+    def load_all
+      @store.load_all
+    end
+
     # Saves the registry to +file+
     # 
     # @param [String] file the yardoc file to save to
@@ -184,7 +200,7 @@ module YARD
     # Returns the paths of all of the objects in the registry.
     # @param [Boolean] reload whether to load entire database
     # @return [Array<String>] all of the paths in the registry.
-    def paths(reload = true)
+    def paths(reload = false)
       @store.keys(reload).map {|k| k.to_s }
     end
     

data/lib/yard/registry_store.rb

@@ -13,6 +13,7 @@ module YARD
       @checksums = {}
       @store = { :root => CodeObjects::RootObject.new(nil, :root) }
       @proxy_types = {}
+      @notfound = {}
       @loaded_objects = 0
       @available_objects = 0
     end
@@ -26,12 +27,16 @@ module YARD
       key = :root if key == ''
       key = key.to_sym
       return @store[key] if @store[key]
-      return nil if @loaded_objects >= @available_objects
+      return if @loaded_objects >= @available_objects
 
       # check disk
+      return if @notfound[key]
       if obj = @serializer.deserialize(key)
         @loaded_objects += 1
         put(key, obj)
+      else
+        @notfound[key] = true
+        nil
       end
     end
     
@@ -58,7 +63,7 @@ module YARD
     # @param [Boolean] reload if false, does not load the entire database
     #   before a lookup.
     # @return [Array<Symbol>] the path names of all the code objects
-    def keys(reload = true) load_all if reload; @store.keys end
+    def keys(reload = false) load_all if reload; @store.keys end
     
     # Gets all code objects from the store. Loads the entire database
     # if +reload+ is +true+
@@ -66,7 +71,7 @@ module YARD
     # @param [Boolean] reload if false, does not load the entire database
     #   before a lookup.
     # @return [Array<CodeObjects::Base>] all the code objects
-    def values(reload = true) load_all if reload; @store.values end
+    def values(reload = false) load_all if reload; @store.values end
     
     # @return [CodeObjects::RootObject] the root object
     def root; @store[:root] end
@@ -77,9 +82,45 @@ module YARD
       @file = file
       @store = {}
       @proxy_types = {}
+      @notfound = {}
       @serializer = Serializers::YardocSerializer.new(@file)
       load_yardoc
     end
+
+    # Loads the .yardoc file and loads all cached objects into memory
+    # automatically.
+    # 
+    # @param [String, nil] file the name of the yardoc db to load
+    # @return [Boolean] whether the database was loaded
+    # @see #load_all
+    def load!(file = nil)
+      if load(file)
+        load_all
+        true
+      else
+        false
+      end
+    end
+    
+    # Loads all cached objects into memory
+    # @return [void]
+    def load_all
+      return unless @file
+      return if @loaded_objects >= @available_objects
+      log.debug "Loading entire database: #{@file} ..."
+      objects = []
+      
+      all_disk_objects.sort_by {|x| x.size }.each do |path|
+        if obj = @serializer.deserialize(path, true)
+          objects << obj
+        end
+      end
+      objects.each do |obj|
+        put(obj.path, obj)
+      end
+      @loaded_objects += objects.size
+      log.debug "Loaded database (file='#{@file}' count=#{objects.size} total=#{@available_objects})"
+    end
     
     # Saves the database to disk
     # @param [Boolean] merge if true, merges the data in memory with the
@@ -177,35 +218,17 @@ module YARD
         @store[:root] = root
       end
     end
-    
-    def load_all
-      return unless @file
-      return if @loaded_objects >= @available_objects
-      log.debug "Loading entire database: #{@file} ..."
-      objects = []
-      
-      all_disk_objects.sort_by {|x| x.size }.each do |path|
-        if obj = @serializer.deserialize(path, true)
-          objects << obj
-        end
-      end
-      objects.each do |obj|
-        put(obj.path, obj)
-      end
-      @loaded_objects += objects.size
-      log.debug "Loaded database (file='#{@file}' count=#{objects.size} total=#{@available_objects})"
-    end
 
     def all_disk_objects
       Dir.glob(File.join(objects_path, '**/*')).select {|f| File.file?(f) }
     end
     
     def write_proxy_types
-      File.open(proxy_types_path, 'wb') {|f| f.write(Marshal.dump(@proxy_types)) }
+      File.open!(proxy_types_path, 'wb') {|f| f.write(Marshal.dump(@proxy_types)) }
     end
     
     def write_checksums
-      File.open(checksums_path, 'w') do |f|
+      File.open!(checksums_path, 'w') do |f|
         @checksums.each {|k, v| f.puts("#{k} #{v}") }
       end
     end

data/lib/yard/serializers/file_system_serializer.rb

@@ -1,5 +1,3 @@
-require 'fileutils'
-
 module YARD
   module Serializers
     class FileSystemSerializer < Base
@@ -28,9 +26,8 @@ module YARD
       # @return [String] the written data (for chaining)
       def serialize(object, data)
         path = File.join(basepath, *serialized_path(object))
-        FileUtils.mkdir_p File.dirname(path)
         log.debug "Serializing to #{path}"
-        File.open(path, "wb") {|f| f.write data }
+        File.open!(path, "wb") {|f| f.write data }
       end
       
       # Implements the serialized path of a code object.

data/spec/cli/yri_spec.rb

@@ -13,11 +13,22 @@ describe YARD::CLI::Yardoc do
   describe '#find_object' do
     it "should use cache if available" do
       @yri.stub!(:cache_object)
+      File.should_receive(:exist?).with('.yardoc').and_return(false)
+      File.should_receive(:exist?).with('bar.yardoc').and_return(true)
       Registry.should_receive(:load).with('bar.yardoc')
       Registry.should_receive(:at).with('Foo').and_return('OBJ')
       @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
       @yri.find_object('Foo').should == 'OBJ'
-      @yri.instance_variable_get("@search_paths")[0].should == 'bar.yardoc'
+    end
+    
+    it "should never use cache ahead of current directory's .yardoc" do
+      @yri.stub!(:cache_object)
+      File.should_receive(:exist?).with('.yardoc').and_return(true)
+      Registry.should_receive(:load).with('.yardoc')
+      Registry.should_receive(:at).with('Foo').and_return('OBJ')
+      @yri.instance_variable_set("@cache", {'Foo' => 'bar.yardoc'})
+      @yri.find_object('Foo').should == 'OBJ'
+      @yri.instance_variable_get("@search_paths")[0].should == '.yardoc'
     end
   end
   
@@ -27,4 +38,17 @@ describe YARD::CLI::Yardoc do
       @yri.cache_object('Foo', Registry.yardoc_file)
     end
   end
+  
+  describe '#initialize' do
+    it "should load search paths" do
+      path = %r{/\.yard/yri_search_paths$}
+      File.should_receive(:file?).with(%r{/\.yard/yri_cache$}).and_return(false)
+      File.should_receive(:file?).with(path).and_return(true)
+      File.should_receive(:readlines).with(path).and_return(%w(line1 line2))
+      @yri = YARD::CLI::YRI.new
+      spaths = @yri.instance_variable_get("@search_paths")
+      spaths.should include('line1')
+      spaths.should include('line2')
+    end
+  end
 end

data/spec/core_ext/file_spec.rb

@@ -45,4 +45,20 @@ describe File do
       File.cleanpath('C/../../D').should == "../D"
     end
   end
+  
+  describe '.open!' do
+    it "should create the path before opening" do
+      File.should_receive(:directory?).with('/path/to').and_return(false)
+      FileUtils.should_receive(:mkdir_p).with('/path/to')
+      File.should_receive(:open).with('/path/to/file', 'w')
+      File.open!('/path/to/file', 'w')
+    end
+
+    it "should just open the file if the path exists" do
+      File.should_receive(:directory?).with('/path/to').and_return(true)
+      FileUtils.should_not_receive(:mkdir_p)
+      File.should_receive(:open).with('/path/to/file', 'w')
+      File.open!('/path/to/file', 'w')
+    end
+  end
 end

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -166,10 +166,6 @@ if RUBY19
       it "should show proper source for assignment" do
         stmt("A=1").jump(:assign).source.should == "A=1"
       end
-      
-      it "should sho" do
-        p stmt("A = Struct.new :a, :b")[1].parameters
-      end
     end
   end
 end

data/spec/parser/source_parser_spec.rb

@@ -109,7 +109,6 @@ describe YARD::Parser::SourceParser do
       hash = Registry.checksum_for(data)
       cmock = mock(:cmock)
       cmock.should_receive(:[]).with('foo/bar').and_return(hash)
-      log.should_receive(:info)
       Registry.should_receive(:checksums).and_return(cmock)
       File.should_receive(:file?).with('foo/bar').and_return(true)
       IO.should_receive(:read).with('foo/bar').and_return(data)

data/spec/registry_spec.rb

@@ -4,6 +4,75 @@ include CodeObjects
 describe YARD::Registry do
   before { Registry.clear }
   
+  describe '.yardoc_file_for_gem' do
+    before do
+      @gem = mock('gem')
+      @gem.stub!(:name).and_return('foo')
+      @gem.stub!(:full_name).and_return('foo-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/foo')
+    end
+    
+    it "should return nil if gem isn't found" do
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([])
+      Registry.yardoc_file_for_gem('foo').should == nil
+    end
+    
+    it "should allow version to be specified" do
+      Gem.source_index.should_receive(:find_name).with('foo', '= 2').and_return([])
+      Registry.yardoc_file_for_gem('foo', '= 2').should == nil
+    end
+    
+    it "should return existing .yardoc path for gem when for_writing=false" do
+      File.should_receive(:exist?).and_return(false)
+      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should == '/path/to/foo/.yardoc'
+    end
+    
+    it "should return nil if no .yardoc path exists in gem when for_writing=false" do
+      File.should_receive(:exist?).and_return(false)
+      File.should_receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should == nil
+    end
+    
+    it "should search local gem path first if for_writing=false" do
+      File.should_receive(:exist?).and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo').should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    end
+    
+    it "should return global .yardoc path for gem if for_writing=true and dir is writable" do
+      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(true)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo', '>= 0', true).should == '/path/to/foo/.yardoc'
+    end
+
+    it "should return local .yardoc path for gem if for_writing=true and dir is not writable" do
+      File.should_receive(:writable?).with(@gem.full_gem_path).and_return(false)
+      Gem.source_index.should_receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      Registry.yardoc_file_for_gem('foo', '>= 0', true).should =~ %r{/.yard/gem_index/foo-1.0.yardoc$}
+    end
+    
+    it "should return gem path if gem starts with yard-doc- and for_writing=false" do
+      @gem.stub!(:name).and_return('yard-doc-core')
+      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
+      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      Registry.yardoc_file_for_gem('yard-doc-core').should == '/path/to/yard-doc-core/.yardoc'
+    end
+    
+    it "should return nil if gem starts with yard-doc- and for_writing=true" do
+      @gem.stub!(:name).and_return('yard-doc-core')
+      @gem.stub!(:full_name).and_return('yard-doc-core-1.0')
+      @gem.stub!(:full_gem_path).and_return('/path/to/yard-doc-core')
+      Gem.source_index.should_receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      File.should_receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true).should == nil
+    end
+  end
+  
   describe '#root' do
     it "should have an empty path for root" do
       Registry.root.path.should == ""

data/spec/registry_store_spec.rb

@@ -115,7 +115,7 @@ describe YARD::RegistryStore do
         File.should_receive(:directory?).with('foo').and_return(true)
         @store.load('foo')
         @store.should_receive(:load_all)
-        @store.send(item)
+        @store.send(item, true)
       end
     
       it "should not load entire database if reload=false" do

data/spec/yard_spec.rb

@@ -43,5 +43,13 @@ describe YARD do
       log.should_receive(:debug).with(/Loading plugin 'yard-plugin3'/).once
       YARD.load_plugins.should == true
     end
+    
+    it "should not load plugins starting with yard-doc-" do
+      mock = mock('yard-doc-core')
+      mock.should_receive(:name).at_least(1).times.and_return('yard-doc-core')
+      Gem.source_index.should_receive(:find_name).with('').and_return([mock])
+      YARD.should_not_receive(:require)
+      YARD.load_plugins.should == true
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yard
 version: !ruby/object:Gem::Version 
-  version: 0.5.0
+  version: 0.5.1p1
 platform: ruby
 authors: 
 - Loren Segal
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 -05:00
+date: 2009-12-16 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -371,9 +371,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.3.1
   version: 
 requirements: []