yard 0.7.4 → 0.7.5

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

@@ -256,6 +256,7 @@ module YARD
         undef on_bare_assoc_hash
         undef on_assoclist_from_args
         undef on_aref
+        undef on_aref_field
         undef on_lbracket
         undef on_rbracket
         undef on_qwords_new
@@ -309,12 +310,19 @@ module YARD
         end
 
         def on_aref(*args)
+          @map[:lbracket].pop
           ll, lc = *@map[:aref].pop
           sr = args.first.source_range.first..lc
           lr = args.first.line_range.first..ll
           AstNode.new(:aref, args, :char => sr, :line => lr)
         end
-        
+
+        def on_aref_field(*args)
+          @map[:lbracket].pop
+          AstNode.new(:aref_field, args,
+                      :listline => lineno..lineno, :listchar => charno...charno)
+        end
+
         def on_array(other)
           node = AstNode.node_class_for(:array).new(:array, [other])
           map = @map[MAPPINGS[node.type]]
@@ -323,6 +331,10 @@ module YARD
             node.source_range = Range.new(sstart, @ns_charno - 1)
             node.line_range = Range.new(lstart, lineno)
           else
+            sstart = other.source_range.begin
+            lstart = other.line_range.begin
+            node.source_range = Range.new(sstart, @ns_charno - 1)
+            node.line_range = Range.new(lstart, lineno)
             node.source_range = other.source_range
             node.line_range = other.line_range
           end

data/lib/yard/registry_store.rb

@@ -139,7 +139,7 @@ module YARD
       destroy unless merge
 
       sdb = Registry.single_object_db
-      if sdb == true || (sdb == nil && keys.size < 3000)
+      if sdb == true || sdb == nil
         @serializer.serialize(@store)
       else
         values(false).each do |object|

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

@@ -31,7 +31,7 @@ module YARD
 
         def initialize(opts = {})
           super
-          self.serializer = DocServerSerializer.new(self)
+          self.serializer = DocServerSerializer.new
         end
 
         def call(request)
@@ -69,6 +69,7 @@ module YARD
               else
                 yardoc.parse_arguments
               end
+              yardoc.send(:verify_markup_options)
               yardoc.options.delete(:serializer)
               options.update(yardoc.options.to_hash)
             end

data/lib/yard/server/doc_server_helper.rb

@@ -10,9 +10,8 @@ module YARD
       def url_for(obj, anchor = nil, relative = false)
         return '' if obj.nil?
         return "/#{obj}" if String === obj
-        super(obj, anchor, false)
+        File.join('', base_path(router.docs_prefix), super(obj, anchor, false))
       end
-
       # Modifies {Templates::Helpers::HtmlHelper#url_for_file} to return a URL instead
       # of a disk location.
       # @param (see Templates::Helpers::HtmlHelper#url_for_file)
@@ -30,7 +29,8 @@ module YARD
       # @param [String] path the path prefix for a base path URI
       # @return [String] the base URI for a library with an extra +path+ prefix
       def base_path(path)
-        path + (@single_library ? '' : "/#{@library}")
+        libname = router.request.version_supplied ? @library.to_s : @library.name
+        path + (@single_library ? '' : "/#{libname}")
       end
 
       # @return [Router] convenience method for accessing the router

data/lib/yard/server/doc_server_serializer.rb

@@ -7,24 +7,24 @@ module YARD
     class DocServerSerializer < Serializers::FileSystemSerializer
       include WEBrick::HTTPUtils
 
-      def initialize(command)
-        super(:command => command, :extension => '')
+      def initialize(command = nil)
+        super(:basepath => '', :extension => '')
       end
 
       def serialized_path(object)
-        path = case object
+        case object
         when CodeObjects::RootObject
           "toplevel"
         when CodeObjects::MethodObject
-          return escape_path(serialized_path(object.namespace) + (object.scope == :instance ? ":" : ".") + object.name.to_s)
+          serialized_path(object.namespace) +
+            (object.scope == :instance ? ":" : ".") + escape(object.name.to_s)
         when CodeObjects::ConstantObject, CodeObjects::ClassVariableObject
-          return escape_path(serialized_path(object.namespace)) + "##{object.name}-#{object.type}"
+          serialized_path(object.namespace) + "##{object.name}-#{object.type}"
+        when CodeObjects::ExtraFileObject
+          super(object).gsub(/^file./, 'file/')
         else
-          object.path.gsub('::', '/')
+          super(object)
         end
-        command = options[:command]
-        library_path = command.single_library ? '' : '/' + command.library.to_s
-        return escape_path(File.join('', command.adapter.router.docs_prefix, library_path, path))
       end
     end
   end

data/lib/yard/server/rack_adapter.rb

@@ -78,6 +78,7 @@ end
 
 # @private
 class Rack::Request
+  attr_accessor :version_supplied
   alias query params
   def xhr?; (env['HTTP_X_REQUESTED_WITH'] || "").downcase == "xmlhttprequest" end
 end

data/lib/yard/server/router.rb

@@ -80,8 +80,10 @@ module YARD
         if libs = adapter.libraries[paths.first]
           paths.shift
           if library = libs.find {|l| l.version == paths.first }
+            request.version_supplied = true if request
             paths.shift
           else # use the last lib in the list
+            request.version_supplied = false if request
             library = libs.last
           end
         end

data/lib/yard/server/templates/doc_server/library_list/html/contents.erb

@@ -3,7 +3,7 @@
   <li class="r<%= @row = @row == 1 ? 2 : 1 %>">
     <% library_versions = library_versions.dup %>
     <% first_lib = library_versions.pop %>
-    <a href="/<%= router.docs_prefix %>/<%= first_lib %>/frames"><%= name %></a>
+    <a href="/<%= router.docs_prefix %>/<%= first_lib.name %>/frames"><%= name %></a>
     <% if first_lib.version %>
       <small>(<%= first_lib.version %><% if library_versions.size > 0 %>,
         <%= library_versions.reverse.map {|lib| "<a href=\"/#{router.docs_prefix}/#{lib}/frames\">#{lib.version}</a>" }.join(', ') %><% end %>)</small>

data/lib/yard/server/templates/doc_server/search/html/search.erb

@@ -7,8 +7,7 @@
       <% name = result.type == :method ? result.name(true).to_s : result.name.to_s %>
       <% path = name.gsub(/(#{Regexp.quote @query})/i, '<strong>\1</strong>') %>
       <li class="r<%= n %>">
-        <a href="<%= serializer.serialized_path(result) %>"
-          title="<%= result.path %>"><%= path %></a>
+        <a href="<%= url_for(result) %>" title="<%= result.path %>"><%= path %></a>
           <% if !result.namespace.root? %>
           <small>(<%= result.namespace.path %>)</small>
           <% end %>

data/lib/yard/server/webrick_adapter.rb

@@ -38,5 +38,6 @@ end
 
 # @private
 class WEBrick::HTTPRequest
+  attr_accessor :version_supplied
   def xhr?; (self['X-Requested-With'] || "").downcase == 'xmlhttprequest' end
 end

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

@@ -44,14 +44,9 @@ module YARD
           html = html.encode(:invalid => :replace, :replace => '?')
         end
         html = resolve_links(html)
-        html = html.gsub(/<pre\s*(?:lang="(.+?)")?>(?:\s*<code>)?(.+?)(?:<\/code>\s*)?<\/pre>/m) do
-          language = $1
-          string   = $2 
-          
-          string = html_syntax_highlight(CGI.unescapeHTML(string), language) unless options[:no_highlight]
-          classes = ['code', language].compact.join(' ')
-          %Q{<pre class="#{classes}">#{string}</pre>}
-        end unless [:text, :none, :pre].include?(markup)
+        unless [:text, :none, :pre].include?(markup)
+          html = parse_codeblocks(html)
+        end
         html
       end
 
@@ -128,11 +123,11 @@ module YARD
       def html_markup_html(text)
         text
       end
-      
+
       # Highlights Ruby source. Similar to {#html_syntax_highlight}, but
       # this method is meant to be called from {#htmlify} when markup is
       # set to "ruby".
-      # 
+      #
       # @param [String] source the Ruby source
       # @return [String] the highlighted HTML
       # @since 0.7.0
@@ -153,21 +148,15 @@ module YARD
       #   +html_syntax_highlight_TYPE+ in this class.
       #
       # @param [String] source the source code to highlight
-      # @param [Symbol] type the language type (:ruby, :plain, etc). Use
+      # @param [Symbol, String] type the language type (:ruby, :plain, etc). Use
       #   :plain for no syntax highlighting.
       # @return [String] the highlighted source
       def html_syntax_highlight(source, type = nil)
         return "" unless source
         return h(source) if options[:no_highlight]
 
-        type ||= object.source_type || :ruby
-
-        # handle !!!LANG prefix to send to html_syntax_highlight_LANG
-        if source =~ /\A(?:[ \t]*\r?\n)?[ \t]*!!!([\w.+-]+)[ \t]*\r?\n/
-          type, source = $1, $'
-          source = $'
-        end
-
+        new_type, source = parse_lang_for_codeblock(source)
+        type ||= new_type || :ruby
         meth = "html_syntax_highlight_#{type}"
         respond_to?(meth) ? send(meth, source) : h(source)
       end
@@ -201,12 +190,12 @@ module YARD
           next(match[1..-1]) if escape
 
           next(match) if name[0,1] == '|'
-          
+
           if name == '<a' && title =~ /href=["'](.+?)["'].*>.*<\/a>\s*(.*)\Z/
             name, title = $1, $2
             title = nil if title.empty?
           end
-          
+
           if object.is_a?(String)
             object
           else
@@ -235,7 +224,7 @@ module YARD
         return title || file.title unless serializer
         link_url(url_for_file(file, anchor), title || file.title)
       end
-      
+
       # (see BaseHelper#link_include_file)
       def link_include_file(file)
         unless file.is_a?(CodeObjects::ExtraFileObject)
@@ -514,6 +503,43 @@ module YARD
         end
         meth
       end
+
+      # Parses !!!lang out of codeblock, returning the codeblock language
+      # followed by the source code.
+      # 
+      # @param [String] source the source code whose language to determine
+      # @return [Array(String, String)] the language, if any, and the 
+      #   remaining source
+      # @since 0.7.5
+      def parse_lang_for_codeblock(source)
+        type = nil
+        if source =~ /\A(?:[ \t]*\r?\n)?[ \t]*!!!([\w.+-]+)[ \t]*\r?\n/
+          type, source = $1, $'
+        end
+
+        [type, source]
+      end
+      
+      # Parses code blocks out of html and performs syntax highlighting
+      # on code inside of the blocks.
+      # 
+      # @param [String] html the html to search for code in
+      # @return [String] highlighted html
+      # @see #html_syntax_highlight
+      def parse_codeblocks(html)
+        html.gsub(/<pre\s*(?:lang="(.+?)")?>(?:\s*<code\s*(?:class="(.+?)")?\s*>)?(.+?)(?:<\/code>\s*)?<\/pre>/m) do
+          string = $3
+          # handle !!!LANG prefix to send to html_syntax_highlight_LANG
+          language, _ = parse_lang_for_codeblock(string)
+          language ||= $1 || $2 || object.source_type
+
+          unless options[:no_highlight]
+            string = html_syntax_highlight(CGI.unescapeHTML(string), language)
+          end
+          classes = ['code', language].compact.join(' ')
+          %Q{<pre class="#{classes}"><code>#{string}</code></pre>}
+        end
+      end
     end
   end
 end

data/spec/cli/yardoc_spec.rb

@@ -269,6 +269,23 @@ describe YARD::CLI::Yardoc do
         @yardoc.run *%w( --asset foo:bar )
         @yardoc.assets.should == {'foo' => 'bar'}
       end
+      
+      it "should not put from inside of to/ if from is a directory" do
+        begin
+          from = 'tmp_foo'
+          to = 'tmp_bar'
+          full_to = File.join(File.dirname(__FILE__), to)
+          FileUtils.mkdir_p(from)
+          @yardoc.options[:serializer].basepath = File.dirname(__FILE__)
+          @yardoc.run("--asset", "#{from}:#{to}")
+          @yardoc.run("--asset", "#{from}:#{to}")
+          File.directory?(full_to).should be_true
+          File.directory?(File.join(full_to, 'tmp_foo')).should be_false
+        ensure
+          FileUtils.rm_rf(from)
+          FileUtils.rm_rf(full_to)
+        end
+      end
     end
   end
   

data/spec/code_objects/base_spec.rb

@@ -298,7 +298,7 @@ describe YARD::CodeObjects::Base do
     it "should allow extra docstring after (see Path)" do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }
       o = ClassObject.new(:root, :Me)
-      o.docstring = "(see AnotherObject)\n\nEXTRA\n@api private"
+      o.docstring = Docstring.new("(see AnotherObject)\n\nEXTRA\n@api private", o)
       o.docstring.should == "FOO\n\nEXTRA"
       o.docstring.should have_tag(:api)
     end

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

@@ -69,6 +69,10 @@ end
   # @return [NotBoolean, nil]
   def boolean3?; end
 
+  # @overload rainy?
+  #   @return whether today is the rainy day.
+  def rainy?; end
+
   attr_writer :attr_name
   def attr_name; end
 

data/spec/handlers/macro_handler_spec.rb

@@ -154,4 +154,13 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MacroHandler"
     obj.should_not be_nil
     obj.signature.should == 'def beep(a, b, c)'
   end
+  
+  it "should not detect implicit macros with invalid method names" do
+    undoc_error <<-eof
+      ##
+      # IMPLICIT METHOD THAT SHOULD 
+      # NOT BE DETECTED
+      dsl_method '/foo/bar'
+    eof
+  end
 end

data/spec/handlers/method_handler_spec.rb

@@ -106,6 +106,13 @@ describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler"
     meth.tag(:return).types.should == ['NotBoolean', 'nil']
   end
   
+  it "should not change return type for method ending in ? with return types set by @overload" do
+    meth = P('Foo#rainy?')
+    meth.should have_tag(:overload)
+    meth.tag(:overload).should have_tag(:return)
+    meth.should_not have_tag(:return)
+  end
+  
   it "should add method writer to existing attribute" do
     Registry.at('Foo#attr_name').should be_reader
     Registry.at('Foo#attr_name=').should be_writer

data/spec/parser/c_parser_spec.rb

@@ -5,18 +5,23 @@ class YARD::Parser::CParser; def ensure_loaded!(a, b=1) a end end
 
 describe YARD::Parser::CParser do
   describe '#parse' do
-    before(:all) do
-      file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
-      @parser = Parser::CParser.new(IO.read(file))
-      @parser.parse
+    def parse(src = @contents)
+      YARD::Registry.clear
+      Parser::CParser.new(src).parse
     end
 
-    def parse
-      Registry.clear
-      Parser::CParser.new(@contents).parse
+    def parse_init(src = @contents)
+      YARD::Registry.clear
+      Parser::CParser.new("void Init_Foo() {\n#{src}\n}").parse
     end
 
     describe 'Array class' do
+      before(:all) do
+        file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
+        @parser = Parser::CParser.new(IO.read(file))
+        @parser.parse
+      end
+
       it "should parse Array class" do
         obj = YARD::Registry.at('Array')
         obj.should_not be_nil
@@ -72,6 +77,49 @@ describe YARD::Parser::CParser do
       end
     end
     
+    describe 'Handling namespace parsing' do
+      it 'should track variable names defined under namespaces' do
+        @contents = <<-eof
+          void Init_Foo(void) {
+              mFoo = rb_define_module("Foo");
+              cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+              rb_define_method(cBar, "foo", foo, 1);
+          }
+        eof
+        parse
+        Registry.at('Foo::Bar').should_not be_nil
+        Registry.at('Foo::Bar#foo').should_not be_nil
+      end
+
+      it 'should track variable names defined under namespaces' do
+        @contents = <<-eof
+          void Init_Foo(void) {
+              mFoo = rb_define_module("Foo");
+              cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+              mBaz = rb_define_module_under(cBar, "Baz");
+              rb_define_method(mBaz, "foo", foo, 1);
+          }
+        eof
+        parse
+        Registry.at('Foo::Bar::Baz').should_not be_nil
+        Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+      end
+      
+      it "should handle rb_path2class() calls" do
+        @contents = <<-eof
+          void Init_Foo(void) {
+              somePath = rb_path2class("Foo::Bar::Baz")
+              mFoo = rb_define_module("Foo");
+              cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
+              mBaz = rb_define_module_under(cBar, "Baz");
+              rb_define_method(somePath, "foo", foo, 1);
+          }
+        eof
+        parse
+        Registry.at('Foo::Bar::Baz#foo').should_not be_nil
+      end
+    end
+    
     describe 'Defining methods with source in other files' do
       it "should look in another file for method" do
         File.should_receive(:read).at_least(1).times.with('file.c').and_return(<<-eof)
@@ -134,7 +182,7 @@ describe YARD::Parser::CParser do
           void Init_Foo() {
             rb_cFoo = rb_define_class("Foo", rb_cObject);
             #{commented ? '/*' : ''} 
-              rb_define_attr(rb_cFoo, "foo", foo, #{read}, #{write});
+              rb_define_attr(rb_cFoo, "foo", #{read}, #{write});
             #{commented ? '*/' : ''}
           }
         eof
@@ -166,6 +214,67 @@ describe YARD::Parser::CParser do
       end
     end
     
+    describe 'Defining constants' do
+      it "should register constants" do
+        parse_init <<-eof
+          mFoo = rb_define_module("Foo");
+          rb_define_const(mFoo, "FOO", ID2SYM(100));
+        eof
+        Registry.at('Foo::FOO').type.should == :constant
+      end
+
+      it "should look for override comments" do
+        parse <<-eof
+          /* Document-const: FOO
+           * Foo bar!
+           */
+
+          void Init_Foo() {
+            mFoo = rb_define_module("Foo");
+            rb_define_const(mFoo, "FOO", ID2SYM(100));
+          }
+        eof
+        foo = Registry.at('Foo::FOO')
+        foo.type.should == :constant
+        foo.docstring.should == 'Foo bar!'
+        foo.value.should == 'ID2SYM(100)'
+        foo.file.should == '(stdin)'
+      end
+
+      it "should use comment attached to declaration as fallback" do
+        parse_init <<-eof
+          mFoo = rb_define_module("Foo");
+          /* foobar! */
+          rb_define_const(mFoo, "FOO", ID2SYM(100));
+        eof
+        foo = Registry.at('Foo::FOO')
+        foo.value.should == 'ID2SYM(100)'
+        foo.docstring.should == 'foobar!'
+      end
+
+      it "should allow the form VALUE: DOCSTRING to document value" do
+        parse_init <<-eof
+          mFoo = rb_define_module("Foo");
+          /* 100: foobar! */
+          rb_define_const(mFoo, "FOO", ID2SYM(100));
+        eof
+        foo = Registry.at('Foo::FOO')
+        foo.value.should == '100'
+        foo.docstring.should == 'foobar!'
+      end
+
+      it "should allow escaping of backslashes in VALUE: DOCSTRING syntax" do
+        parse_init <<-eof
+          mFoo = rb_define_module("Foo");
+          /* 100\\:x\\:y: foobar:x! */
+          rb_define_const(mFoo, "FOO", ID2SYM(100));
+        eof
+        foo = Registry.at('Foo::FOO')
+        foo.value.should == '100:x:y'
+        foo.docstring.should == 'foobar:x!'
+      end
+    end
+    
     describe 'Defining aliases' do
       before do
         Registry.clear
@@ -186,6 +295,22 @@ describe YARD::Parser::CParser do
         Registry.at('Foo#bar').should be_is_alias
         Registry.at('Foo#bar').docstring.should == 'FOO'
       end
+
+      it "should allow defining of aliases (rb_define_alias) of attributes" do
+        @contents = <<-eof
+          /* FOO */
+          VALUE foo(VALUE x) { int value = x; }
+          void Init_Foo() {
+            rb_cFoo = rb_define_class("Foo", rb_cObject);
+            rb_define_attr(rb_cFoo, "foo", 1, 0);
+            rb_define_alias(rb_cFoo, "foo?", "foo");
+          }
+        eof
+        parse
+
+        Registry.at('Foo#foo').should be_reader
+        Registry.at('Foo#foo?').should be_is_alias
+      end
     end
   end
 
@@ -228,4 +353,4 @@ describe YARD::Parser::CParser do
       neg_self.source.should be_nil
     end
   end
-end
+end