yard 0.6.4 → 0.6.5

data/spec/parser/source_parser_spec.rb

@@ -1,10 +1,8 @@
 require File.join(File.dirname(__FILE__), '..', 'spec_helper')
 
+class MyParser < Parser::Base; end
+
 shared_examples_for "parser type registration" do
-  before do
-    class MyParser < Parser::Base; end
-  end
-  
   after do
     Parser::SourceParser.parser_types.delete(:my_parser)
     Parser::SourceParser.parser_type_extensions.delete(:my_parser)
@@ -80,6 +78,22 @@ describe YARD::Parser::SourceParser do
       Registry.at("Hello::Hi#me").docstring.line_range.should == (3..4)
     end
     
+    it "should parse Ruby code with metaclasses" do
+      YARD.parse_string(<<-eof)
+        module Hello
+          class Hi
+            class <<self
+              # Docstring
+              def me; "VALUE" end
+            end
+          end
+        end
+      eof
+      Registry.at(:Hello).should_not == nil
+      Registry.at("Hello::Hi.me").should_not == nil
+      Registry.at("Hello::Hi.me").docstring.should == "Docstring"
+    end
+    
     it "should only use prepended comments for an object" do
       YARD.parse_string(<<-eof)
         # Test
@@ -137,6 +151,23 @@ describe YARD::Parser::SourceParser do
       YARD.parse_string "=begin\nfoo\n\nbar\n=end\nclass Foo; end\n"
       Registry.at(:Foo).docstring.should == "foo\n\nbar"
     end
+    
+    it "should know about docstrings starting with ##" do
+      {'#' => false, '##' => true}.each do |hash, expected|
+        YARD.parse_string "#{hash}\n# Foo bar\nclass Foo; end"
+        Registry.at(:Foo).docstring.hash_flag.should == expected
+      end
+    end
+    
+    it "should remove shebang from initial file comments" do
+      YARD.parse_string "#!/bin/ruby\n# this is a comment\nclass Foo; end"
+      Registry.at(:Foo).docstring.should == "this is a comment"
+    end
+    
+    it "should remove encoding line from initial file comments" do
+      YARD.parse_string "# encoding: utf-8\n# this is a comment\nclass Foo; end"
+      Registry.at(:Foo).docstring.should == "this is a comment"
+    end
   end
 
   describe '#parse' do
@@ -232,10 +263,13 @@ describe YARD::Parser::SourceParser do
           parser = Parser::SourceParser.new
           File.should_receive(:read_binary).with('tmpfile').and_return(src)
           result = parser.parse("tmpfile")
-          result.enumerator[0].source.encoding.to_s.send(msg) == 'Shift_JIS'
+          if HAVE_RIPPER && RUBY19
+            result.enumerator[0].source.encoding.to_s.send(msg) == 'Shift_JIS'
+          end
+          result.encoding_line.send(msg) == src.split("\n").last
         end
       end
-    end if RUBY19
+    end
   end
   
   describe '#parse_in_order' do
@@ -269,7 +303,7 @@ describe YARD::Parser::SourceParser do
       YARD::Parser::SourceParser.parse_string("int main() { }", :d)
     end
     
-    if RUBY19
+    if HAVE_RIPPER
       it "should display a warning for a syntax error (with new parser)" do
         err_msg = "Syntax error in `(stdin)`:(1,3): syntax error, unexpected $undefined, expecting $end"
         log.should_receive(:warn).with(err_msg)

data/spec/rake/yardoc_task_spec.rb

@@ -4,17 +4,17 @@ describe YARD::Rake::YardocTask do
   before do
     @yardoc = mock(:cli)
     YARD::CLI::Yardoc.stub!(:new).and_return(@yardoc)
-    Rake.application.clear
+    ::Rake.application.clear
   end
   
   def run
-    Rake.application.tasks[0].invoke
+    ::Rake.application.tasks[0].invoke
   end
   
   describe '#initialize' do
     it "should allow separate rake task name to be set" do
       YARD::Rake::YardocTask.new(:notyardoc)
-      Rake.application.tasks[0].name.should == "notyardoc"
+      ::Rake.application.tasks[0].name.should == "notyardoc"
     end
   end
   

data/spec/registry_spec.rb

@@ -236,4 +236,56 @@ describe YARD::Registry do
       Registry.instance.should == Registry
     end
   end
+  
+  describe '.single_object_db' do
+    it "should default to nil" do
+      Registry.single_object_db.should == nil
+      Thread.new { Registry.single_object_db.should == nil }.join
+    end
+  end
+  
+  describe 'Thread local' do
+    it "should maintain two Registries in separate threads" do
+      barrier = 0
+      threads = []
+      threads << Thread.new do 
+        Registry.clear
+        YARD.parse_string "# docstring 1\nclass Foo; end"
+        barrier += 1
+        while barrier < 2 do end
+        Registry.at('Foo').docstring.should == "docstring 1"
+      end
+      threads << Thread.new do
+        Registry.clear
+        YARD.parse_string "# docstring 2\nclass Foo; end"
+        barrier += 1
+        while barrier < 2 do end
+        Registry.at('Foo').docstring.should == "docstring 2"
+      end
+      threads.each {|t| t.join }
+    end
+    
+    it "should allow setting of yardoc_file in separate threads" do
+      barrier = 0
+      threads = []
+      threads << Thread.new do 
+        Registry.yardoc_file.should == '.yardoc'
+        Registry.yardoc_file = 'foo'
+        barrier += 1
+        while barrier == 1 do end
+        Registry.yardoc_file.should == 'foo'
+      end
+      threads << Thread.new do
+        while barrier == 0 do end
+        Registry.yardoc_file.should == '.yardoc'
+        barrier += 1
+        Registry.yardoc_file = 'foo2'
+      end
+      threads.each {|t| t.join }
+    end
+    
+    it "should automatically clear in new threads" do
+      Thread.new { Registry.all.should be_empty }.join
+    end
+  end
 end

data/spec/registry_store_spec.rb

@@ -1,9 +1,23 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
 describe YARD::RegistryStore do
-  before { @store = RegistryStore.new }
+  before do
+    @store = RegistryStore.new
+    @serializer = Serializers::YardocSerializer.new('foo')
+    Serializers::YardocSerializer.stub!(:new).and_return(@serializer)
+  end
   
   describe '#load' do
+    it "should load root.dat as full object list if it is a Hash" do
+      File.should_receive(:directory?).with('foo').and_return(true)
+      File.should_receive(:file?).with('foo/checksums').and_return(false)
+      File.should_receive(:file?).with('foo/proxy_types').and_return(false)
+      @serializer.should_receive(:deserialize).with('root').and_return({:root => 'foo', :A => 'bar'})
+      @store.load('foo').should == true
+      @store.root.should == 'foo'
+      @store.get('A').should == 'bar'
+    end
+    
     it "should load old yardoc format if .yardoc is a file" do
       File.should_receive(:directory?).with('foo').and_return(false)
       File.should_receive(:file?).with('foo').and_return(true)
@@ -78,6 +92,62 @@ describe YARD::RegistryStore do
     end
   end
   
+  describe '#save' do
+    before do
+      @store.stub!(:write_proxy_types)
+      @store.stub!(:write_checksums)
+      @store.stub!(:destroy)
+    end
+    
+    after do
+      Registry.single_object_db = nil
+    end
+    
+    def saves_to_singledb
+      @serializer.should_receive(:serialize).once.with(instance_of(Hash))
+      @store.save(true, 'foo')
+    end
+    
+    def add_items(n)
+      n.times {|i| @store[i.to_s] = 'foo' }
+    end
+    
+    def saves_to_multidb
+      times = @store.keys.size
+      @serializer.should_receive(:serialize).exactly(times).times
+      @store.save(true, 'foo')
+      @last = times
+    end
+    
+    it "should save as single object db if single_object_db is nil and there are less than 3000 objects" do
+      Registry.single_object_db = nil
+      add_items(100)
+      saves_to_singledb
+    end
+    
+    it "should not save as single object db if single_object_db is nil and there are more than 3000 objects" do
+      Registry.single_object_db = nil
+      add_items(5000)
+      saves_to_multidb
+    end
+    
+    it "should save as single object db if single_object_db is true (and any amount of objects)" do
+      Registry.single_object_db = true
+      add_items(100)
+      saves_to_singledb
+      add_items(5000)
+      saves_to_singledb
+    end
+    
+    it "should never save as single object db if single_object_db is false" do
+      Registry.single_object_db = false
+      add_items(100)
+      saves_to_multidb
+      add_items(5000)
+      saves_to_multidb
+    end
+  end
+  
   describe '#put' do
     it "should assign values" do
       @store.put(:YARD, true)

data/spec/serializers/yardoc_serializer_spec.rb

@@ -8,15 +8,15 @@ instance_eval do
 end
 
 describe YARD::Serializers::YardocSerializer do
-  describe '#dump' do
-    before do
-      @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
+  before do
+    @serializer = YARD::Serializers::YardocSerializer.new('.yardoc')
 
-      Registry.clear
-      @foo = CodeObjects::ClassObject.new(:root, :Foo)
-      @bar = CodeObjects::MethodObject.new(@foo, :bar)
-    end
+    Registry.clear
+    @foo = CodeObjects::ClassObject.new(:root, :Foo)
+    @bar = CodeObjects::MethodObject.new(@foo, :bar)
+  end
 
+  describe '#dump' do
     it "should maintain object equality when loading a dumped object" do
       newfoo = @serializer.internal_dump(@foo)
       newfoo.should equal(@foo)
@@ -32,4 +32,15 @@ describe YARD::Serializers::YardocSerializer do
       {newfoo => 1}.should have_key(@foo)
     end
   end
+  
+  describe '#serialize' do
+    it "should accept a hash of codeobjects (and write to root)" do
+      data = {:root => Registry.root}
+      marshaldata = Marshal.dump(data)
+      filemock = mock(:file)
+      filemock.should_receive(:write).with(marshaldata)
+      File.should_receive(:open!).with('.yardoc/objects/root.dat', 'wb').and_yield(filemock)
+      @serializer.serialize(data)
+    end
+  end
 end

data/spec/server/rack_adapter_spec.rb

@@ -12,7 +12,7 @@ describe "YARD::Server::RackMiddleware" do
   end
   
   it "should pass up to the next middleware on 404" do
-    @superapp.should_receive(:call).and_return([200, {}, 'OK'])
-    @app.call(Rack::MockRequest.env_for('/INVALID')).should == [200, {}, 'OK']
+    @superapp.should_receive(:call).and_return([200, {}, ['OK']])
+    @app.call(Rack::MockRequest.env_for('/INVALID')).should == [200, {}, ['OK']]
   end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,16 @@ end
 
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'yard'))
 
+unless defined?(HAVE_RIPPER)
+  begin require 'ripper'; rescue LoadError; end
+  HAVE_RIPPER = defined?(::Ripper) && !ENV['LEGACY'] ? true : false
+  LEGACY_PARSER = !HAVE_RIPPER
+  
+  class YARD::Parser::SourceParser
+    def self.parser_type; :ruby18 end
+  end if ENV['LEGACY']
+end
+
 def parse_file(file, thisfile = __FILE__, log_level = log.level, ext = '.rb.txt')
   Registry.clear
   path = File.join(File.dirname(thisfile), 'examples', file.to_s + ext)

data/spec/tags/default_factory_spec.rb

@@ -1,136 +1,138 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe YARD::Tags::DefaultFactory, "extract_types_and_name_from_text" do
+describe YARD::Tags::DefaultFactory do
   before { @f = YARD::Tags::DefaultFactory.new }
-  
-  def parse_types(types)
-    @f.send(:extract_types_and_name_from_text, types)
-  end
-  
-  it "should handle one type" do
-    parse_types('[A]').should == [nil, ['A'], ""]
-  end
 
-  it "should handle a list of types" do
-    parse_types('[A, B, C]').should == [nil, ['A', 'B', 'C'], ""]
-  end
-  
-  it "should return the text before and after the type list" do
-    parse_types(' b <String> description').should == ['b', ['String'], 'description']
-    parse_types('b c <String> description (test)').should == [nil, nil, 'b c <String> description (test)']
+  describe '#parse_tag' do
+    it "should not have trailing whitespace on a regular freeform tag" do
+      @f.parse_tag('api', 'private     ').text.should == "private"
+    end
   end
-  
-  it "should handle a complex list of types" do
-    v = parse_types(' [Test, Array<String, Hash, C>, String]')
-    v.should include(["Test", "Array<String, Hash, C>", "String"])
-  end
-  
-  it "should handle any of the following start/end delimiting chars: (), <>, {}, []" do
-    a = parse_types('[a,b,c]')
-    b = parse_types('<a,b,c>')
-    c = parse_types('(a,b,c)')
-    d = parse_types('{a,b,c}')
-    a.should == b
-    b.should == c
-    c.should == d
-    a.should include(['a','b','c'])
-  end
-  
-  it "should return the text before the type list as the last element" do
-    parse_types('b[x, y, z]').should == ['b', ['x', 'y', 'z'], '']
-    parse_types('  ! <x>').should == ["!", ['x'], '']
-  end
-  
-  it "should return text unparsed if there is no type list" do
-    parse_types('').should == [nil, nil, '']
-    parse_types('[]').should == [nil, nil, '[]']
-  end
-  
-  it "should allow A => B syntax" do
-    v = parse_types(' [Test, Array<String, Hash{A => {B => C}}, C>, String]')
-    v.should include(["Test", "Array<String, Hash{A => {B => C}}, C>", "String"])
-  end
-end
 
-describe YARD::Tags::DefaultFactory, '#parse_tag_with_types' do
-  before { @f = YARD::Tags::DefaultFactory.new }
-  
-  def parse_types(text)
-    @f.send(:parse_tag_with_types, 'test', text)
-  end
-  
-  it "should parse given types and description" do
-    YARD::Tags::Tag.should_receive(:new).with("test", "description", ["x", "y", "z"])
-    parse_types(' [x, y, z] description')
-  end
-  
-  it "should parse given types only" do
-    YARD::Tags::Tag.should_receive(:new).with("test", "", ["x", "y", "z"])
-    parse_types(' [x, y, z] ')
-  end
-  
-  it "should allow type list to be omitted" do
-    YARD::Tags::Tag.should_receive(:new).with('test', 'description', nil)
-    parse_types('  description    ')
-  end
-  
-  it "should raise an error if a name is specified before type list" do
-    lambda { parse_types('b<String> desc') }.should raise_error(YARD::Tags::TagFormatError, 'cannot specify a name before type list for \'@test\'')
-  end
-end
+  describe '#extract_types_and_name_from_text' do
+    def parse_types(types)
+      @f.send(:extract_types_and_name_from_text, types)
+    end
+  
+    it "should handle one type" do
+      parse_types('[A]').should == [nil, ['A'], ""]
+    end
 
-describe YARD::Tags::DefaultFactory, '#parse_tag_with_types_name_and_default' do
-  before { @f = YARD::Tags::DefaultFactory.new }
-  
-  def parse_types(text)
-    @f.send(:parse_tag_with_types_name_and_default, 'test', text)
-  end
-  
-  it "should parse a standard type list with name before types (no default)" do
-    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
-    parse_types('NAME [x, y, z] description')
+    it "should handle a list of types" do
+      parse_types('[A, B, C]').should == [nil, ['A', 'B', 'C'], ""]
+    end
+  
+    it "should return the text before and after the type list" do
+      parse_types(' b <String> description').should == ['b', ['String'], 'description']
+      parse_types('b c <String> description (test)').should == [nil, nil, 'b c <String> description (test)']
+    end
+  
+    it "should handle a complex list of types" do
+      v = parse_types(' [Test, Array<String, Hash, C>, String]')
+      v.should include(["Test", "Array<String, Hash, C>", "String"])
+    end
+  
+    it "should handle any of the following start/end delimiting chars: (), <>, {}, []" do
+      a = parse_types('[a,b,c]')
+      b = parse_types('<a,b,c>')
+      c = parse_types('(a,b,c)')
+      d = parse_types('{a,b,c}')
+      a.should == b
+      b.should == c
+      c.should == d
+      a.should include(['a','b','c'])
+    end
+  
+    it "should return the text before the type list as the last element" do
+      parse_types('b[x, y, z]').should == ['b', ['x', 'y', 'z'], '']
+      parse_types('  ! <x>').should == ["!", ['x'], '']
+    end
+  
+    it "should return text unparsed if there is no type list" do
+      parse_types('').should == [nil, nil, '']
+      parse_types('[]').should == [nil, nil, '[]']
+    end
+  
+    it "should allow A => B syntax" do
+      v = parse_types(' [Test, Array<String, Hash{A => {B => C}}, C>, String]')
+      v.should include(["Test", "Array<String, Hash{A => {B => C}}, C>", "String"])
+    end
   end
 
-  it "should parse a standard type list with name after types (no default)" do
-    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
-    parse_types('  [x, y, z] NAME description')
-  end
-  
-  it "should parse a tag definition with name, typelist and default" do
-    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
-    parse_types('  [x, y, z] NAME (default, values) description')
+  describe '#parse_tag_with_types' do
+    def parse_types(text)
+      @f.send(:parse_tag_with_types, 'test', text)
+    end
+  
+    it "should parse given types and description" do
+      YARD::Tags::Tag.should_receive(:new).with("test", "description", ["x", "y", "z"])
+      parse_types(' [x, y, z] description')
+    end
+  
+    it "should parse given types only" do
+      YARD::Tags::Tag.should_receive(:new).with("test", "", ["x", "y", "z"])
+      parse_types(' [x, y, z] ')
+    end
+  
+    it "should allow type list to be omitted" do
+      YARD::Tags::Tag.should_receive(:new).with('test', 'description', nil)
+      parse_types('  description    ')
+    end
+  
+    it "should raise an error if a name is specified before type list" do
+      lambda { parse_types('b<String> desc') }.should raise_error(YARD::Tags::TagFormatError, 'cannot specify a name before type list for \'@test\'')
+    end
   end
 
-  it "should parse a tag definition with name, typelist and default when name is before type list" do
-    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
-    parse_types(' NAME [x, y, z] (default, values) description')
-  end
-  
-  it "should allow typelist to be omitted" do
-    YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", nil, 'NAME', ['default', 'values'])
-    parse_types('  NAME (default, values) description')
-  end
-end
+  describe '#parse_tag_with_types_name_and_default' do
+    def parse_types(text)
+      @f.send(:parse_tag_with_types_name_and_default, 'test', text)
+    end
+  
+    it "should parse a standard type list with name before types (no default)" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+      parse_types('NAME [x, y, z] description')
+    end
 
-describe YARD::Tags::DefaultFactory, '#parse_tag_with_options' do
-  before { @f = YARD::Tags::DefaultFactory.new }
-  
-  def parse_options(text)
-    @f.parse_tag_with_options('option', text)
-  end
+    it "should parse a standard type list with name after types (no default)" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', nil)
+      parse_types('  [x, y, z] NAME description')
+    end
+  
+    it "should parse a tag definition with name, typelist and default" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+      parse_types('  [x, y, z] NAME (default, values) description')
+    end
+
+    it "should parse a tag definition with name, typelist and default when name is before type list" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", ["x", "y", "z"], 'NAME', ['default', 'values'])
+      parse_types(' NAME [x, y, z] (default, values) description')
+    end
   
-  it "should have a name before tag info" do
-    t = parse_options("xyz key [Types] (default) description")
-    t.tag_name.should == 'option'
-    t.name.should == 'xyz'
+    it "should allow typelist to be omitted" do
+      YARD::Tags::DefaultTag.should_receive(:new).with("test", "description", nil, 'NAME', ['default', 'values'])
+      parse_types('  NAME (default, values) description')
+    end
   end
-  
-  it "should parse the rest of the tag like DefaultTag" do
-    t = parse_options("xyz key [Types] (default) description")
-    t.pair.should be_instance_of(Tags::DefaultTag)
-    t.pair.types.should == ["Types"]
-    t.pair.name.should == "key"
-    t.pair.defaults.should == ["default"]
-    t.pair.text.should == "description"
+
+  describe '#parse_tag_with_options' do
+    def parse_options(text)
+      @f.parse_tag_with_options('option', text)
+    end
+  
+    it "should have a name before tag info" do
+      t = parse_options("xyz key [Types] (default) description")
+      t.tag_name.should == 'option'
+      t.name.should == 'xyz'
+    end
+  
+    it "should parse the rest of the tag like DefaultTag" do
+      t = parse_options("xyz key [Types] (default) description")
+      t.pair.should be_instance_of(Tags::DefaultTag)
+      t.pair.types.should == ["Types"]
+      t.pair.name.should == "key"
+      t.pair.defaults.should == ["default"]
+      t.pair.text.should == "description"
+    end
   end
 end