yard 0.7.4 → 0.7.5

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -236,7 +236,23 @@ describe YARD::Parser::Ruby::RubyParser do
         s.jump(:array).source.should == '%w( foo bar )'
       end
     end
-    
+
+    it "should parse %w() array source in object[] parsed context" do
+      s = stmts(<<-eof)
+        {}[:key]
+        FOO = %w( foo bar )
+      eof
+      s[1].jump(:array).source.should == '%w( foo bar )'
+    end
+
+    it "should parse %w() array source in object[]= parsed context" do
+      s = stmts(<<-eof)
+        {}[:key] = :value
+        FOO = %w( foo bar )
+      eof
+      s[1].jump(:array).source.should == '%w( foo bar )'
+    end
+
     it "should parse [] as array" do
       s = stmt(<<-eof)
         class Foo

data/spec/registry_spec.rb

@@ -294,6 +294,7 @@ describe YARD::Registry do
         Registry.yardoc_file = 'foo2'
       end
       threads.each {|t| t.join }
+      Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
     end
     
     it "should automatically clear in new threads" do

data/spec/registry_store_spec.rb

@@ -126,10 +126,10 @@ describe YARD::RegistryStore do
       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
+    it "should 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
+      saves_to_singledb
     end
     
     it "should save as single object db if single_object_db is true (and any amount of objects)" do

data/spec/server/doc_server_helper_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+class MyDocServerSerializerRouter
+  attr_accessor :request
+  def docs_prefix; 'PREFIX' end
+  def initialize; @request = mock_request end
+end
+
+class MockDocServerHelper
+  include YARD::Templates::Helpers::BaseHelper
+  include YARD::Templates::Helpers::HtmlHelper
+  include YARD::Server::DocServerHelper
+
+  attr_accessor :adapter
+  attr_accessor :single_library
+  attr_accessor :library
+
+  def initialize
+    @single_library = false
+    @library = LibraryVersion.new('foo')
+    @adapter = mock_adapter(:router => MyDocServerSerializerRouter.new)
+    @serializer = YARD::Server::DocServerSerializer.new
+    @object = YARD::Registry.root
+  end
+end
+
+describe YARD::Server::DocServerHelper do
+  before do
+    @helper = MockDocServerHelper.new
+  end
+
+  describe '#url_for' do
+    it "should not link to /library/ if single_library = true" do
+      @helper.single_library = true
+      @helper.url_for(Registry.root).should == "/PREFIX/toplevel"
+    end
+
+    it "should return /PREFIX/foo/version if foo has a version" do
+      @helper.library = LibraryVersion.new('foo', 'bar')
+      @helper.adapter.router.request.version_supplied = true
+      @helper.url_for(P('A')).should == '/PREFIX/foo/bar/A'
+    end
+  end
+  
+  describe '#url_for_file' do
+    it "should properly link file objects using file/ prefix" do
+      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
+      @helper.url_for_file(file).should == '/PREFIX/foo/file/a/b/FooBar.md'
+    end
+  end
+end

data/spec/server/doc_server_serializer_spec.rb

@@ -1,58 +1,45 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-class MyDocServerSerializerRouter
-  def docs_prefix; 'PREFIX' end
-end
-
 describe YARD::Server::DocServerSerializer do
   describe '#serialized_path' do
     before do
       Registry.clear
-      @command = mock(:command)
-      @command.stub!(:single_library).and_return(false)
-      @command.stub!(:library).and_return(LibraryVersion.new('foo'))
-      @command.stub!(:adapter).and_return(mock_adapter(:router => MyDocServerSerializerRouter.new))
-      @serializer = Server::DocServerSerializer.new(@command)
+      @serializer = Server::DocServerSerializer.new
     end
 
     after(:all) { Server::Adapter.shutdown }
     
     it "should return '/PREFIX/library/toplevel' for root" do
-      @serializer.serialized_path(Registry.root).should == "/PREFIX/foo/toplevel"
+      @serializer.serialized_path(Registry.root).should == "toplevel"
     end
     
     it "should return /PREFIX/library/Object for Object in a library" do
-      @serializer.serialized_path(P('A::B::C')).should == '/PREFIX/foo/A/B/C'
+      @serializer.serialized_path(P('A::B::C')).should == 'A/B/C'
     end
     
     it "should link to instance method as Class:method" do
       obj = CodeObjects::MethodObject.new(:root, :method)
-      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel:method'
+      @serializer.serialized_path(obj).should == 'toplevel:method'
     end
 
     it "should link to class method as Class.method" do
       obj = CodeObjects::MethodObject.new(:root, :method, :class)
-      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel.method'
+      @serializer.serialized_path(obj).should == 'toplevel.method'
     end
     
     it "should link to anchor for constant" do
       obj = CodeObjects::ConstantObject.new(:root, :FOO)
-      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#FOO-constant'
+      @serializer.serialized_path(obj).should == 'toplevel#FOO-constant'
     end
     
     it "should link to anchor for class variable" do
       obj = CodeObjects::ClassVariableObject.new(:root, :@@foo)
-      @serializer.serialized_path(obj).should == '/PREFIX/foo/toplevel#@@foo-classvariable'
-    end
-    
-    it "should not link to /library/ if single_library = true" do
-      @command.stub!(:single_library).and_return(true)
-      @serializer.serialized_path(Registry.root).should == "/PREFIX/toplevel"
+      @serializer.serialized_path(obj).should == 'toplevel#@@foo-classvariable'
     end
     
-    it "should return /PREFIX/foo/version if foo has a version" do
-      @command.stub!(:library).and_return(LibraryVersion.new('foo', 'bar'))
-      @serializer.serialized_path(P('A')).should == '/PREFIX/foo/bar/A'
+    it "should link files using file/ prefix" do
+      file = CodeObjects::ExtraFileObject.new('a/b/FooBar.md', '')
+      @serializer.serialized_path(file).should == 'file/FooBar'
     end
   end
 end

data/spec/server/rack_adapter_spec.rb

@@ -7,6 +7,8 @@ describe "YARD::Server::RackMiddleware" do
     @app = YARD::Server::RackMiddleware.new(@superapp, :libraries => {'foo' => [LibraryVersion.new('foo', nil)]})
   end
   
+  after(:all) { YARD::Server::Adapter.shutdown }
+  
   it "should handle requests" do
     @app.call(Rack::MockRequest.env_for('/'))[0].should == 200
   end

data/spec/server/router_spec.rb

@@ -12,23 +12,30 @@ describe YARD::Server::Router do
   before do
     @adapter = mock_adapter
     @projects = @adapter.libraries['project']
+    @request = mock_request
   end
 
   describe '#parse_library_from_path' do
     def parse(*args)
-      MyRouterSpecRouter.new(@adapter).parse_library_from_path(args.flatten)
+      @request.path = '/' + args.join('/')
+      @router = MyRouterSpecRouter.new(@adapter)
+      @router.request = @request
+      @router.parse_library_from_path(args.flatten)
     end
     
     it "should parse library and version name out of path" do
       parse('project', '1.0.0').should == [@projects[0], []]
+      @request.version_supplied.should be_true
     end
     
     it "should parse library and use latest version if version is not supplied" do
       parse('project').should == [@projects[1], []]
+      @request.version_supplied.should be_false
     end
 
     it "should parse library and use latest version if next component is not a version" do
       parse('project', 'notaversion').should == [@projects[1], ['notaversion']]
+      @request.version_supplied.should be_false
     end
     
     it "should return nil library if no library is found" do

data/spec/templates/class_spec.rb

@@ -2,6 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe YARD::Templates::Engine.template(:default, :docstring) do
   before do
+    Registry.clear
     YARD.parse_string <<-'eof'
       private
       # Comments
@@ -40,4 +41,4 @@ describe YARD::Templates::Engine.template(:default, :docstring) do
   it "should hide private constructors" do
     html_equals(Registry.at('D').format(:format => :html, :no_highlight => true, :verifier => Verifier.new("!@private")), :class002)
   end
-end
+end

data/spec/templates/examples/module001.html

@@ -204,7 +204,7 @@ and newlines.
   
   
   <h3 class="inherited">Attributes included from BaseMod</h3>
-  <p class="inherited">base_attr1, base_attr2, base_attr3</p>
+  <p class="inherited">#base_attr1, #base_attr2, #base_attr3</p>
 
 
   

data/spec/templates/examples/module003.html

@@ -0,0 +1,186 @@
+<h1>Module: A
+  
+  
+  
+</h1>
+
+<dl class="box">
+  
+  
+    
+  
+    
+      <dt class="r1">Includes:</dt>
+      <dd class="r1">B</dd>
+      
+    
+  
+  
+  
+    <dt class="r2 last">Defined in:</dt>
+    <dd class="r2 last">(stdin)</dd>
+  
+</dl>
+<div class="clear"></div>
+
+
+  <h2>Constant Summary</h2>
+  
+    <dl class="constants">
+      
+        <dt id="FOO-constant" class="">FOO =
+          
+        </dt>
+        <dd><pre class="code">2</pre></dd>
+      
+    </dl>
+  
+
+
+
+
+  <h2>Instance Attribute Summary <small>(<a href="#" class="summary_toggle">collapse</a>)</small></h2>
+  <ul class="summary">
+    
+      <li class="public ">
+  <span class="summary_signature">
+    
+      <a  title="#bar (instance method)">- <strong>bar</strong> </a>
+    
+
+    
+  </span>
+  
+  
+    <span class="note title readonly">readonly</span>
+    
+  
+  
+  
+  
+  
+
+  
+    <span class="summary_desc"><div class='inline'>Returns the value of attribute bar.</div></span>
+  
+</li>
+
+    
+  </ul>
+
+
+
+
+  
+    <h2>
+      Instance Method Summary
+      <small>(<a href="#" class="summary_toggle">collapse</a>)</small>
+    </h2>
+
+    <ul class="summary">
+      
+        <li class="public ">
+  <span class="summary_signature">
+    
+      <a  title="#foo (instance method)">- <strong>foo</strong> </a>
+    
+
+    
+  </span>
+  
+  
+  
+  
+  
+  
+
+  
+    <span class="summary_desc"><div class='inline'></div></span>
+  
+</li>
+
+      
+    </ul>
+  
+
+
+  
+  
+  
+  
+  
+  <div id="instance_attr_details" class="attr_details">
+    <h2>Instance Attribute Details</h2>
+    
+      
+      <span id=""></span>
+      <span id="bar-instance_method"></span>
+      <div class="method_details first">
+  <p class="signature first" id="bar-instance_method">
+  
+    - <strong>bar</strong>  <span class="extras">(readonly)</span>
+  
+
+  
+</p><div class="docstring">
+  <div class="discussion">
+    Returns the value of attribute bar
+
+  </div>
+</div>
+<div class="tags">
+  
+
+</div><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+11
+12
+13</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 11</span>
+
+def bar
+  @bar
+end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+    
+  </div>
+
+
+  <div id="instance_method_details" class="method_details_list">
+    <h2>Instance Method Details</h2>
+    
+    
+      <div class="method_details first">
+  <p class="signature first" id="foo-instance_method">
+  
+    - <strong>foo</strong> 
+  
+
+  
+</p><table class="source_code">
+  <tr>
+    <td>
+      <pre class="lines">
+
+
+10</pre>
+    </td>
+    <td>
+      <pre class="code"><span class="info file"># File '(stdin)', line 10</span>
+
+def foo; end</pre>
+    </td>
+  </tr>
+</table>
+</div>
+    
+  </div>

data/spec/templates/helpers/html_helper_spec.rb

@@ -142,7 +142,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       log.enter_level(Logger::FATAL) do
         pending 'This test depends on markdown' unless markup_class(:markdown)
       end
-      htmlify('http://example.com', :markdown).chomp.should ==
+      htmlify('http://example.com', :markdown).chomp.gsub('/', '/').should ==
         '<p><a href="http://example.com">http://example.com</a></p>'
     end
     
@@ -471,40 +471,46 @@ describe YARD::Templates::Helpers::HtmlHelper do
   end
 
   describe '#html_syntax_highlight' do
-    before do
-      stub!(:options).and_return(:no_highlight => false)
-      stub!(:object).and_return(Registry.root)
-    end
-    
-    def fix_rspec2_mock_teardown
-      return unless defined?(RSpec)
-      should_receive(:respond_to?).with(:teardown_mocks_for_rspec).and_return(false)
-      should_receive(:respond_to?).with(:verify_mocks_for_rspec).and_return(false)
+    subject do
+      obj = OpenStruct.new
+      obj.options = {:no_highlight => false}
+      obj.object = Registry.root
+      obj.extend(Templates::Helpers::HtmlHelper)
+      obj
     end
     
     it "should return empty string on nil input" do
-      html_syntax_highlight(nil).should == ''
+      subject.html_syntax_highlight(nil).should == ''
     end
     
     it "should call #html_syntax_highlight_ruby by default" do
       Registry.root.source_type = nil
-      should_receive(:html_syntax_highlight_ruby).with('def x; end')
-      html_syntax_highlight('def x; end')
+      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end')
+      subject.html_syntax_highlight('def x; end')
     end
     
     it "should call #html_syntax_highlight_NAME if there's an object with a #source_type" do
-      Registry.root.source_type = :NAME
-      fix_rspec2_mock_teardown
-      should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
-      should_receive(:html_syntax_highlight_NAME).and_return("foobar")
-      html_syntax_highlight('def x; end').should == 'foobar'
+      subject.object = OpenStruct.new(:source_type => :NAME)
+      subject.should_receive(:respond_to?).with('html_markup_html').and_return(true)
+      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
+      subject.should_receive(:html_syntax_highlight_NAME).and_return("foobar")
+      subject.htmlify('<pre><code>def x; end</code></pre>', :html).should == 
+        '<pre class="code NAME"><code>foobar</code></pre>'
+    end
+    
+    it "should add !!!LANG to className in outputted pre tag" do
+      subject.object = OpenStruct.new(:source_type => :LANG)
+      subject.should_receive(:respond_to?).with('html_markup_html').and_return(true)
+      subject.should_receive(:respond_to?).with('html_syntax_highlight_LANG').and_return(true)
+      subject.should_receive(:html_syntax_highlight_LANG).and_return("foobar")
+      subject.htmlify("<pre><code>!!!LANG\ndef x; end</code></pre>", :html).should == 
+        '<pre class="code LANG"><code>foobar</code></pre>'
     end
 
     it "should call html_syntax_highlight_NAME if source starts with !!!NAME" do
-      fix_rspec2_mock_teardown
-      should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
-      should_receive(:html_syntax_highlight_NAME).and_return("foobar")
-      html_syntax_highlight(<<-eof
+      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(true)
+      subject.should_receive(:html_syntax_highlight_NAME).and_return("foobar")
+      subject.html_syntax_highlight(<<-eof
         !!!NAME
         def x; end
       eof
@@ -512,21 +518,41 @@ describe YARD::Templates::Helpers::HtmlHelper do
     end
     
     it "should not highlight if :no_highlight option is true" do
-      stub!(:options).and_return(:no_highlight => true)
-      should_not_receive(:html_syntax_highlight_ruby)
-      html_syntax_highlight('def x; end').should == 'def x; end'
+      subject.options[:no_highlight] = true
+      subject.should_not_receive(:html_syntax_highlight_ruby)
+      subject.html_syntax_highlight('def x; end').should == 'def x; end'
     end
     
     it "should not highlight if there is no highlight method specified by !!!NAME" do
-      fix_rspec2_mock_teardown
-      should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(false)
-      should_not_receive(:html_syntax_highlight_NAME)
-      html_syntax_highlight("!!!NAME\ndef x; end").should == "def x; end"
+      subject.should_receive(:respond_to?).with('html_syntax_highlight_NAME').and_return(false)
+      subject.should_not_receive(:html_syntax_highlight_NAME)
+      subject.html_syntax_highlight("!!!NAME\ndef x; end").should == "def x; end"
     end
     
     it "should highlight as ruby if htmlify(text, :ruby) is called" do
-      should_receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
-      htmlify('def x; end', :ruby).should == '<pre class="code ruby">x</pre>'
+      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
+      subject.htmlify('def x; end', :ruby).should == '<pre class="code ruby">x</pre>'
+    end
+    
+    it "should not prioritize object source type when called directly" do
+      subject.should_receive(:html_syntax_highlight_ruby).with('def x; end').and_return('x')
+      subject.object = OpenStruct.new(:source_type => :c)
+      subject.html_syntax_highlight("def x; end").should == "x"
+    end
+    
+    it "shouldn't escape code snippets twice" do
+      subject.htmlify('<pre lang="foo"><code>{"foo" => 1}</code></pre>', :html).should == 
+        '<pre class="code foo"><code>{&quot;foo&quot; =&gt; 1}</code></pre>'
+    end
+    
+    it "should highlight source when matching a pre lang= tag" do
+      subject.htmlify('<pre lang="foo"><code>x = 1</code></pre>', :html).should == 
+        '<pre class="code foo"><code>x = 1</code></pre>'
+    end
+    
+    it "should highlight source when matching a code class= tag" do
+      subject.htmlify('<pre><code class="foo">x = 1</code></pre>', :html).should == 
+        '<pre class="code foo"><code>x = 1</code></pre>'
     end
   end