yard 0.8.3 → 0.8.4

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

@@ -23,11 +23,11 @@ module YARD
             output << "<span class='tstring'>" if [:tstring_beg, :regexp_beg].include?(s[0])
             case s.first
             when :nl, :ignored_nl, :sp
-              output << h(s.last)
+              output << h(s[1])
             when :ident
-              output << "<span class='id identifier rubyid_#{h(s.last)}'>#{h(s.last)}</span>"
+              output << "<span class='id identifier rubyid_#{h(s[1])}'>#{h(s[1])}</span>"
             else
-              output << "<span class='#{s.first}'>#{h(s.last)}</span>"
+              output << "<span class='#{s.first}'>#{h(s[1])}</span>"
             end
             output << "</span>" if [:tstring_end, :regexp_end].include?(s[0])
           end

data/lib/yard/version.rb

@@ -1,3 +1,3 @@
 module YARD
-  VERSION = "0.8.3"
+  VERSION = "0.8.4"
 end

data/spec/cli/server_spec.rb

@@ -173,6 +173,24 @@ describe YARD::CLI::Server do
       run '--daemon'
     end
 
+    it "should accept -B, --bind" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com'
+      run '--bind', 'example.com'
+    end    
+
+    it "should bind address with WebRick adapter" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com', '-a', 'webrick'
+      run '--bind', 'example.com', '-a', 'webrick'
+    end  
+
+    it "should bind address with Rack adapter" do
+      @server_options[:Host] = 'example.com'
+      run '-B', 'example.com', '-a', 'rack'
+      run '--bind', 'example.com', '-a', 'rack'
+    end          
+
     it "should accept -p, --port" do
       @server_options[:Port] = 10
       run '-p', '10'

data/spec/code_objects/base_spec.rb

@@ -333,6 +333,37 @@ describe YARD::CodeObjects::Base do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
       o.docstring.should == "FOO"
     end
+
+    describe 'localization' do
+      it "should return localized docstring" do
+        fr_locale = YARD::I18n::Locale.new('fr')
+        fr_locale.stub!(:translate).with('Hello').and_return('Bonjour')
+
+        o = ClassObject.new(:root, :Me)
+        o.docstring = 'Hello'
+        o.docstring.should == 'Hello'
+
+        Registry.stub!(:locale).with('fr').and_return(fr_locale)
+        o.docstring('fr').should == "Bonjour"
+      end
+
+      it "should return updated localized docstring" do
+        fr_locale = YARD::I18n::Locale.new('fr')
+        Registry.stub!(:locale).with('fr').and_return(fr_locale)
+
+        o = ClassObject.new(:root, :Me)
+        o.docstring = 'Hello'
+        o.docstring.should == 'Hello'
+
+        fr_locale.stub!(:translate).with('Hello').and_return('Bonjour')
+        o.docstring('fr').should == "Bonjour"
+
+        o.docstring = 'World'
+        fr_locale.stub!(:translate).with('World').and_return('Monde')
+        o.docstring('fr').should == "Monde"
+        o.docstring.should == 'World'
+      end
+    end
   end
 
   describe '#add_file' do
@@ -404,4 +435,4 @@ describe YARD::CodeObjects::Base do
       foo.copy_to(bar)
     end
   end
-end
+end

data/spec/handlers/base_spec.rb

@@ -40,6 +40,15 @@ describe YARD::Handlers::Base do
     end
   end
 
+  describe '#abort! (and HandlerAborted)' do
+    it 'should allow HandlerAborted to be raised' do
+      class AbortHandler1 < Handlers::Ruby::Base
+        process { abort! }
+      end
+      lambda { AbortHandler1.new(nil, nil).process }.should raise_error(HandlerAborted)
+    end
+  end
+
   describe 'transitive tags' do
     it "should add transitive tags to children" do
       Registry.clear

data/spec/handlers/dsl_handler_spec.rb

@@ -61,7 +61,7 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
     obj = Registry.at('Foo.xyz')
     obj.should_not be_nil
     obj.signature.should == 'def xyz(a, b, c)'
-    obj.parameters.should == [[:a, nil], [:b, nil], [:c, nil]]
+    obj.parameters.should == [['a', nil], ['b', nil], ['c', nil]]
     obj.source.should == 'foo_bar'
     obj.docstring.should == 'The foo method'
   end
@@ -163,6 +163,12 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
     Registry.at('Baz#y_parser').should_not be_nil
   end
 
+  it "should look through mixins for attached macros" do
+    meth = Registry.at('Baz#mixin_method')
+    meth.should_not be_nil
+    meth.docstring.should == 'DSL method mixin_method'
+  end
+
   it "should handle top-level DSL methods" do
     obj = Registry.at('#my_other_method')
     obj.should_not be_nil
@@ -175,6 +181,11 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}DSLHandler" do
     obj.signature.should == 'def beep(a, b, c)'
   end
 
+  it "should expand attached macros in first DSL method" do
+    Registry.at('DSLMethods#foo').docstring.should == "Returns String for foo"
+    Registry.at('DSLMethods#bar').docstring.should == "Returns Integer for bar"
+  end
+
   it "should not detect implicit macros with invalid method names" do
     undoc_error <<-eof
       ##

data/spec/handlers/examples/dsl_handler_001.rb.txt

@@ -93,13 +93,21 @@ class Foo
   a_module_function :modfunc1
 end
 
+module MyMixin
+  # @!macro [attach] special
+  #   DSL method $1
+  def defined_by_mixin; end
+end
+
 class Bar
   parser :x_parser
 end
 
 class Baz < Foo
+  extend MyMixin
   parser :y_parser
   none { }
+  defined_by_mixin :mixin_method
 end
 
 # @!method my_other_method
@@ -107,4 +115,11 @@ end
 method_that_makes_a_method
 
 # @!macro something
-foobarbaz :beep
+foobarbaz :beep
+
+module DSLMethods
+  # @macro [attach] dsl_method
+  #   Returns $2 for $1
+  dsl_method :foo, String
+  dsl_method :bar, Integer
+end

data/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -24,4 +24,9 @@ class Testing
 
   def Foo; end
   private :Foo
+
+  private
+
+  class Bar; end
+  module Baz; end
 end

data/spec/handlers/method_handler_spec.rb

@@ -55,17 +55,17 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler"
 
     o1 = meth.tags(:overload).first
     o1.name.should == :bar
-    o1.parameters.should == [[:a, nil], [:b, "1"]]
+    o1.parameters.should == [['a', nil], ['b', "1"]]
     o1.tag(:return).type.should == "String"
 
     o2 = meth.tags(:overload)[1]
     o2.name.should == :baz
-    o2.parameters.should == [[:b, nil], [:c, nil]]
+    o2.parameters.should == [['b', nil], ['c', nil]]
     o2.tag(:return).type.should == "Fixnum"
 
     o3 = meth.tags(:overload)[2]
     o3.name.should == :bang
-    o3.parameters.should == [[:d, nil], [:e, nil]]
+    o3.parameters.should == [['d', nil], ['e', nil]]
     o3.docstring.should be_empty
     o3.docstring.should be_blank
   end

data/spec/handlers/processor_spec.rb

@@ -20,4 +20,15 @@ describe YARD::Handlers::Processor do
   it "should have a globals structure" do
     @proc.globals.should be_a(OpenStruct)
   end
-end
+
+  it 'should ignore HandlerAborted exceptions (but print debug info)' do
+    class AbortHandlerProcessor < YARD::Handlers::Ruby::Base
+      process { abort! }
+    end
+    stmt = OpenStruct.new(:line => 1, :show => 'SOURCE')
+    @proc.stub!(:find_handlers).and_return([AbortHandlerProcessor])
+    log.should_receive(:debug).with(/AbortHandlerProcessor cancelled from/)
+    log.should_receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
+    @proc.process([stmt])
+  end
+end

data/spec/handlers/visibility_handler_spec.rb

@@ -31,4 +31,9 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHand
   it "should handle constants passed in as symbols" do
     Registry.at('Testing#Foo').visibility.should == :private
   end
+
+  it 'should not register classes with visibility' do
+    Registry.at('Testing::Bar').visibility.should == :public
+    Registry.at('Testing::Baz').visibility.should == :public
+  end
 end

data/spec/parser/ruby/ruby_parser_spec.rb

@@ -296,6 +296,19 @@ eof
       stmt("X = !1").jump(:unary).source.should == '!1'
     end
 
+    it "should have the correct line range for class/modules" do
+      s = stmt(<<-eof)
+        class Foo
+          def foo; end
+
+
+
+          # Ending comment
+        end
+      eof
+      s.jump(:class).line_range.should == (1..7)
+    end
+
     it "should find lone comments" do
       Registry.clear
       ast = YARD.parse_string(<<-eof).enumerator

data/spec/parser/source_parser_spec.rb

@@ -628,6 +628,10 @@ describe YARD::Parser::SourceParser do
   end
 
   describe '#parse_statements' do
+    before do
+      Registry.clear
+    end
+
     it "should display a warning for invalid parser type" do
       log.should_receive(:warn).with(/unrecognized file/)
       log.should_receive(:backtrace)
@@ -644,7 +648,6 @@ describe YARD::Parser::SourceParser do
     end
 
     it "should handle groups" do
-      Registry.clear
       YARD.parse_string <<-eof
         class A
           # @group Group Name
@@ -666,5 +669,39 @@ describe YARD::Parser::SourceParser do
       Registry.at('A#foo2').group.should == "Group Name"
       Registry.at('A#baz').group.should == "Group 2"
     end
+
+    it 'handles multi-line class/module references' do
+      YARD.parse_string <<-eof
+        class A::
+          B::C; end
+      eof
+      Registry.all.should == [P('A::B::C')]
+    end
+
+    it 'handles sclass definitions of multi-line class/module references' do
+      YARD.parse_string <<-eof
+        class << A::
+          B::C
+          def foo; end
+        end
+      eof
+      Registry.all.size.should == 2
+      Registry.at('A::B::C').should_not be_nil
+      Registry.at('A::B::C.foo').should_not be_nil
+    end
+
+    it 'handles lone comment blocks at the end of a namespace' do
+      YARD.parse_string <<-eof
+        module A
+          class B
+            def c; end
+
+            # @!method d
+          end
+        end
+      eof
+      Registry.at('A#d').should be_nil
+      Registry.at('A::B#d').should_not be_nil
+    end
   end
 end

data/spec/server/doc_server_helper_spec.rb

@@ -22,6 +22,8 @@ class MockDocServerHelper
     @serializer = YARD::Server::DocServerSerializer.new
     @object = YARD::Registry.root
   end
+
+  def options; OpenStruct.new end
 end
 
 describe YARD::Server::DocServerHelper do

data/spec/tags/directives_spec.rb

@@ -138,6 +138,13 @@ describe YARD::Tags::MacroDirective do
       baz.visibility.should == :public
     end
 
+    it "should expand macro if defined on class method and there is no data block" do
+      tag_parse("@!macro [new] attached3\n  expanded_data")
+      baz = CodeObjects::MethodObject.new(P('Foo::Bar'), :baz, :class)
+      doc = DocstringParser.new.parse('@!macro attached3', baz, handler).to_docstring
+      doc.should == 'expanded_data'
+    end
+
     it "should not attempt to expand macro values if handler = nil" do
       tag_parse("@!macro [attach] xyz\n  $1 $2 $3")
     end
@@ -243,7 +250,7 @@ describe YARD::Tags::MethodDirective do
       YARD.parse_string <<-eof
         # @!method foo(a, b, c = nil)
       eof
-      Registry.at('#foo').parameters.should == [[:a, nil], [:b, nil], [:c, 'nil']]
+      Registry.at('#foo').parameters.should == [['a', nil], ['b', nil], ['c', 'nil']]
     end
 
     it "should be able to define method with module scope (module function)" do

data/spec/tags/overload_tag_spec.rb

@@ -12,7 +12,7 @@ describe YARD::Tags::OverloadTag do
 
   it "should parse the first line as a method signature" do
     @tag.signature.should == "def bar(a, b = 1, &block)"
-    @tag.parameters.should == [[:a, nil], [:b, "1"], [:"&block", nil]]
+    @tag.parameters.should == [['a', nil], ['b', "1"], ['&block', nil]]
   end
 
   it "should parse the rest of the text as a new Docstring" do

data/spec/templates/helpers/html_helper_spec.rb

@@ -207,6 +207,16 @@ describe YARD::Templates::Helpers::HtmlHelper do
       link_object("Bar").should =~ %r{>Bar</a>}
     end
 
+    it "should use #title if overridden" do
+      CodeObjects::ModuleObject.new(:root, :YARD)
+      CodeObjects::ClassObject.new(P('YARD'), :Bar)
+      Registry.at('YARD::Bar').stub(:title).and_return('TITLE!')
+      stub!(:object).and_return(Registry.at('YARD::Bar'))
+      serializer = Serializers::FileSystemSerializer.new
+      stub!(:serializer).and_return(serializer)
+      link_object("Bar").should =~ %r{>TITLE!</a>}
+    end
+
     it "should use relative path to parent class in title" do
       root = CodeObjects::ModuleObject.new(:root, :YARD)
       obj = CodeObjects::ModuleObject.new(root, :SubModule)
@@ -249,6 +259,16 @@ describe YARD::Templates::Helpers::HtmlHelper do
       url_for(P("Mod::Class#meth")).should be_nil
     end
 
+    it "should return nil if object is hidden" do
+      yard = CodeObjects::ModuleObject.new(:root, :YARD)
+
+      stub!(:serializer).and_return Serializers::FileSystemSerializer.new
+      stub!(:object).and_return Registry.root
+      stub!(:options).and_return OpenStruct.new(:verifier => Verifier.new('false'))
+
+      url_for(yard).should be_nil
+    end
+
     it "should return nil if serializer does not implement #serialized_path" do
       stub!(:serializer).and_return Serializers::Base.new
       stub!(:object).and_return Registry.root
@@ -516,7 +536,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       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>'
+        '<pre class="code NAME"><code class="NAME">foobar</code></pre>'
     end
 
     it "should add !!!LANG to className in outputted pre tag" do
@@ -525,7 +545,7 @@ describe YARD::Templates::Helpers::HtmlHelper do
       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>'
+        '<pre class="code LANG"><code class="LANG">foobar</code></pre>'
     end
 
     it "should call html_syntax_highlight_NAME if source starts with !!!NAME" do
@@ -563,17 +583,17 @@ describe YARD::Templates::Helpers::HtmlHelper do
 
     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>'
+        '<pre class="code foo"><code class="foo">{&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>'
+        '<pre class="code foo"><code class="foo">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>'
+        '<pre class="code foo"><code class="foo">x = 1</code></pre>'
     end
   end
 

data/templates/default/class/setup.rb

@@ -8,7 +8,7 @@ end
 
 def constructor_details
   ctors = object.meths(:inherited => true, :included => true)
-  return unless @ctor = ctors.find {|o| o.name == :initialize }
+  return unless @ctor = ctors.find {|o| o.constructor? }
   return if prune_method_listing([@ctor]).empty?
   erb(:constructor_details)
 end

data/templates/default/module/html/box_info.erb

@@ -17,7 +17,7 @@
     <% n = 2 %>
   <% end %>
   <% [[:class, "Extended by"], [:instance, "Includes"]].each do |scope, name| %>
-    <% if (mix = object.mixins(scope)).size > 0 %>
+    <% if (mix = run_verifier(object.mixins(scope))).size > 0 %>
       <dt class="r<%=n%>"><%= name %>:</dt>
       <dd class="r<%=n%>"><%= mix.sort_by {|o| o.path }.map {|o| linkify(o) }.join(", ") %></dd>
       <% n = n == 2 ? 1 : 2 %>