yard 0.8.1 → 0.8.2

data/lib/yard/parser/c/c_parser.rb

@@ -55,7 +55,7 @@ module YARD
         end
 
         def consume_directive
-          return unless @newline
+          return(advance) unless @newline
           @last_comment = nil
           @last_statement = nil
           advance_loop do

data/lib/yard/parser/source_parser.rb

@@ -40,8 +40,9 @@ module YARD
       # @see Processor#parse_remaining_files
       def parse
         while file = files.shift
-          log.debug("Processing #{file}...")
-          SourceParser.new(SourceParser.parser_type, @global_state).parse(file)
+          log.capture("Parsing #{file}") do
+            SourceParser.new(SourceParser.parser_type, @global_state).parse(file)
+          end
         end
       end
     end
@@ -446,10 +447,10 @@ module YARD
         @parser
       rescue ArgumentError, NotImplementedError => e
         log.warn("Cannot parse `#{file}': #{e.message}")
-        log.backtrace(e) if log.level >= Logger::DEBUG
+        log.backtrace(e, :warn)
       rescue ParserSyntaxError => e
         log.warn(e.message.capitalize)
-        log.backtrace(e) if log.level >= Logger::DEBUG
+        log.backtrace(e, :warn)
       end
 
       # Tokenizes but does not parse the block of code using the current {#parser_type}

data/lib/yard/registry.rb

@@ -20,13 +20,14 @@ module YARD
   # the Registry thread local. This means all access to a registry for a specific
   # object set must occur in the originating thread.
   #
-  # @example Loading a Registry
+  # @example Loading the Registry
   #   Registry.load!('/path/to/yardocfile') # loads all objects into memory
   #   Registry.at('YARD::CodeObjects::Base').docstring
   #   # => "+Base+ is the superclass of all code objects ..."
-  # @example Performing a Search on a Registry
-  #   Registry.resolve(P('YARD::CodeObjects::Base'), '#docstring')
-  #   # => <
+  # @example Getting an object by a specific path
+  #   Registry.at('YARD::CodeObjects::Base#docstring')
+  # @example Performing a lookup on a method anywhere in the inheritance tree
+  #   Registry.resolve(P('YARD::CodeObjects::Base'), '#docstring', true)
   module Registry
     DEFAULT_YARDOC_FILE = ".yardoc"
     LOCAL_YARDOC_INDEX = File.expand_path('~/.yard/gem_index')
@@ -259,14 +260,16 @@ module YARD
       #   when performing name resolution if set to +true+.
       # @param [Boolean] proxy_fallback If +true+, returns a proxy representing
       #   the unresolved path (namespace + name) if no object is found.
+      # @param [Symbol, nil] type the {CodeObjects::Base#type} that the resolved
+      #   object must be equal to. No type checking if nil.
       # @return [CodeObjects::Base] the object if it is found
       # @return [CodeObjects::Proxy] a Proxy representing the object if
       #   +proxy_fallback+ is +true+.
       # @return [nil] if +proxy_fallback+ is +false+ and no object was found.
       # @see P
-      def resolve(namespace, name, inheritance = false, proxy_fallback = false)
+      def resolve(namespace, name, inheritance = false, proxy_fallback = false, type = nil)
         if namespace.is_a?(CodeObjects::Proxy)
-          return proxy_fallback ? CodeObjects::Proxy.new(namespace, name) : nil
+          return proxy_fallback ? CodeObjects::Proxy.new(namespace, name, type) : nil
         end
 
         if namespace == :root || !namespace
@@ -279,7 +282,8 @@ module YARD
         name = name.to_s
         if name =~ /^#{CodeObjects::NSEPQ}/
           [name, name[2..-1]].each do |n|
-            return at(n) if at(n)
+            found = at(n)
+            return found if found && (type.nil? || found.type == type)
           end
         else
           while namespace
@@ -297,14 +301,14 @@ module YARD
               end
               nss.each do |ns|
                 next if ns.is_a?(CodeObjects::Proxy)
-                found = partial_resolve(ns, name)
+                found = partial_resolve(ns, name, type)
                 return found if found
               end
             end
             namespace = namespace.parent
           end
         end
-        proxy_fallback ? CodeObjects::Proxy.new(orignamespace, name) : nil
+        proxy_fallback ? CodeObjects::Proxy.new(orignamespace, name, type) : nil
       end
 
       # @group Managing Source File Checksums
@@ -338,6 +342,7 @@ module YARD
       # The assumed types of a list of paths. This method is used by CodeObjects::Base
       # @return [{String => Symbol}] a set of unresolved paths and their assumed type
       # @private
+      # @deprecated The registry no longer globally tracks proxy types.
       def proxy_types
         thread_local_store.proxy_types
       end
@@ -358,8 +363,11 @@ module YARD
       #
       # @param [CodeObjects::NamespaceObject] namespace the starting namespace
       # @param [String] name the name to look for
-      def partial_resolve(namespace, name)
-        return at(name) || at('#' + name) if namespace.root?
+      # @param [Symbol, nil] type the {CodeObjects::Base#type} that the resolved
+      #   object must be equal to
+      def partial_resolve(namespace, name, type = nil)
+        obj = at(name) || at('#' + name) if namespace.root?
+        return obj if obj && (type.nil? || obj.type == type)
         [CodeObjects::NSEP, CodeObjects::CSEP, ''].each do |s|
           next if s.empty? && name =~ /^\w/
           path = name
@@ -367,7 +375,7 @@ module YARD
             path = [namespace.path, name].join(s)
           end
           found = at(path)
-          return found if found
+          return found if found && (type.nil? || found.type == type)
         end
         nil
       end

data/lib/yard/registry_store.rb

@@ -6,7 +6,9 @@ module YARD
   # @see Registry
   # @see Serializers::YardocSerializer
   class RegistryStore
-    attr_reader :proxy_types, :file, :checksums
+    # @deprecated The registry no longer tracks proxy types
+    attr_reader :proxy_types
+    attr_reader :file, :checksums
 
     def initialize
       @file = nil
@@ -207,6 +209,7 @@ module YARD
       @serializer.objects_path
     end
 
+    # @deprecated The registry no longer tracks proxy types
     def proxy_types_path
       @serializer.proxy_types_path
     end
@@ -243,6 +246,7 @@ module YARD
       @store, @proxy_types = *Marshal.load(File.read_binary(@file))
     end
 
+    # @deprecated The registry no longer tracks proxy types
     def load_proxy_types
       return unless File.file?(proxy_types_path)
       @proxy_types = Marshal.load(File.read_binary(proxy_types_path))
@@ -283,6 +287,7 @@ module YARD
       Dir.glob(File.join(objects_path, '**/*')).select {|f| File.file?(f) }
     end
 
+    # @deprecated The registry no longer tracks proxy types
     def write_proxy_types
       File.open!(proxy_types_path, 'wb') {|f| f.write(Marshal.dump(@proxy_types)) }
     end

data/lib/yard/rubygems/doc_manager.rb

@@ -1,3 +1,4 @@
+require 'rubygems/user_interaction'
 require 'rubygems/doc_manager'
 
 class Gem::DocManager
@@ -7,10 +8,13 @@ class Gem::DocManager
 
   def run_yardoc(*args)
     args << '--quiet'
-    args << @spec.require_paths
-    if @spec.extra_rdoc_files.size > 0
-      args << '-'
-      args += @spec.extra_rdoc_files
+    args << '--backtrace' if Gem.configuration.backtrace
+    unless File.file?(File.join(@spec.full_gem_path, '.yardopts'))
+      args << @spec.require_paths
+      if @spec.extra_rdoc_files.size > 0
+        args << '-'
+        args += @spec.extra_rdoc_files
+      end
     end
     args = args.flatten.map {|arg| arg.to_s }
 
@@ -23,7 +27,7 @@ class Gem::DocManager
   rescue => ex
     alert_error "While generating documentation for #{@spec.full_name}"
     ui.errs.puts "... MESSAGE:   #{ex}"
-    ui.errs.puts "... YARDDOC args: #{args.join(' ')}"
+    ui.errs.puts "... YARDOC args: #{args.join(' ')}"
     ui.errs.puts "\t#{ex.backtrace.join("\n\t")}" if Gem.configuration.backtrace
     ui.errs.puts "(continuing with the rest of the installation)"
   ensure

data/lib/yard/serializers/yardoc_serializer.rb

@@ -32,6 +32,7 @@ module YARD
       end
 
       def objects_path; File.join(basepath, 'objects') end
+      # @deprecated The registry no longer tracks proxy types
       def proxy_types_path; File.join(basepath, 'proxy_types') end
       def checksums_path; File.join(basepath, 'checksums') end
       def object_types_path; File.join(basepath, 'object_types') end

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

@@ -136,11 +136,12 @@ module YARD
         #   receive +#options+ as an argument.
         # @return [String] the resulting output to display
         def render(object = nil)
+          opts = options.merge(:serialize => false)
           case object
           when CodeObjects::Base
-            cache object.format(options)
+            cache object.format(opts)
           when nil
-            cache Templates::Engine.render(options)
+            cache Templates::Engine.render(opts)
           else
             cache object
           end

data/lib/yard/server/doc_server_serializer.rb

@@ -15,6 +15,8 @@ module YARD
         case object
         when CodeObjects::RootObject
           "toplevel"
+        when CodeObjects::ExtendedMethodObject
+          serialized_path(object.namespace) + ':' + escape(object.name.to_s)
         when CodeObjects::MethodObject
           serialized_path(object.namespace) +
             (object.scope == :instance ? ":" : ".") + escape(object.name.to_s)

data/lib/yard/server/templates/default/method_details/html/permalink.erb

@@ -0,0 +1,4 @@
+<script>
+$("#<%= anchor_for(object) %>").prepend(
+  '<a class="permalink" href="/<%= base_path(router.docs_prefix) %>/<%= serializer.serialized_path(object) %>">permalink</a>');
+</script>

data/lib/yard/server/templates/default/method_details/html/setup.rb

@@ -0,0 +1,4 @@
+def init
+  super
+  sections.place(:permalink).after_any(:method_signature)
+end

data/lib/yard/tags/default_factory.rb

@@ -134,14 +134,20 @@ module YARD
       def extract_types_and_name_from_text_unstripped(text, opening_types = TYPELIST_OPENING_CHARS, closing_types = TYPELIST_CLOSING_CHARS)
         s, e = 0, 0
         before = ''
-        list, level, seen_space = [''], 0, false
-        text.split(//).each_with_index do |c, i|
-          if opening_types.include?(c)
+        list, level, seen_space, i = [''], 0, false, 0
+        last_seen = ''
+        while i < text.length
+          c = text[i, 1]
+          if level > 0 && c == '#' && text[i+1..-1] =~ CodeObjects::METHODNAMEMATCH
+            list.last << c + $&
+            i += $&.length + 1
+            next
+          elsif opening_types.include?(c)
             list.last << c if level > 0
             s = i if level == 0
             level += 1
           elsif closing_types.include?(c)
-            level -= 1 unless list.last[-1,1] == '=' && c == '>'
+            level -= 1 unless last_seen == '=' && c == '>'
             break e = i if level == 0
             list.last << c
           elsif c == ',' && level == 1
@@ -154,6 +160,8 @@ module YARD
           elsif level >= 1
             list.last << c
           end
+          last_seen = c
+          i += 1
         end
 
         before = before.empty? ? nil : before

data/lib/yard/tags/directives.rb

@@ -401,6 +401,7 @@ module YARD
         handler.register_visibility(obj, visibility)
         handler.register_group(obj)
         obj.signature = method_signature
+        obj.parameters = OverloadTag.new(:overload, method_signature).parameters
         obj.docstring = Docstring.new!(parser.text, parser.tags, obj,
           parser.raw_text)
         handler.register_module_function(obj)

data/lib/yard/templates/engine.rb

@@ -82,7 +82,7 @@ module YARD
           options = set_default_options(options)
           mod = template(options.template, options.type, options.format)
 
-          if options.serialize != false
+          if options.serializer && options.serialize != false
             with_serializer(options.object, options.serializer) { mod.run(options) }
           else
             mod.run(options)
@@ -112,11 +112,18 @@ module YARD
         # @yieldreturn [String] the contents to serialize
         # @see Serializers::Base
         def with_serializer(object, serializer, &block)
-          serializer.before_serialize if serializer
-          output = yield
-          if serializer
-            serializer.serialize(object, output)
-            serializer.after_serialize(output)
+          output = nil
+          filename = serializer.serialized_path(object)
+          if serializer.respond_to?(:basepath)
+            filename = File.join(serializer.basepath, filename)
+          end
+          log.capture("Generating #{filename}", nil) do
+            serializer.before_serialize if serializer
+            output = yield
+            if serializer
+              serializer.serialize(object, output)
+              serializer.after_serialize(output)
+            end
           end
           output
         end

data/lib/yard/templates/template_options.rb

@@ -36,11 +36,14 @@ module YARD
       # @return [CodeObjects::Base] the main object being generated in the template
       attr_accessor :object
 
+      # @return [CodeObjects::Base] the owner of the generated object
+      attr_accessor :owner
+
       # @return [Symbol] the template type used to generate output
       attr_accessor :type
 
       # @return [Boolean] whether serialization should be performed
-      default_attr :serialize, false
+      default_attr :serialize, true
 
       # @return [Serializers::Base] the serializer used to generate links and serialize
       #   output. Serialization output only occurs if {#serialize} is +true+.
@@ -70,12 +73,16 @@ module YARD
       # @return [nil] if the mixin is not a module object
       def embed_mixins_match?(mixin)
         return nil unless mixin.is_a?(CodeObjects::ModuleObject)
+        return nil if mixin == object # the method is not inherited
         embed_mixins.any? do |embed_mixin|
           re = /\A#{Regexp.quote(embed_mixin).gsub('\*', '.*')}\Z/
           matchstr = embed_mixin.include?("::") ? mixin.path : mixin.name
           re.match(matchstr.to_s)
         end
       end
+
+      # @return [Verifier] the verifier object
+      attr_accessor :verifier
     end
   end
 end

data/spec/cli/graph_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Yardoc do
+  it "should serialize output" do
+    Registry.should_receive(:load)
+    @graph = YARD::CLI::Graph.new
+    @graph.options.serializer.should_receive(:serialize).once
+    @graph.run
+  end
+end

data/spec/cli/yri_spec.rb

@@ -1,12 +1,14 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-class YARD::CLI::YRI
+class TestYRI < YARD::CLI::YRI
   public :optparse, :find_object, :cache_object
+  def test_stub; end
+  def print_object(*args) test_stub; super end
 end
 
 describe YARD::CLI::YRI do
   before do
-    @yri = YARD::CLI::YRI.new
+    @yri = TestYRI.new
     Registry.stub!(:load)
   end
 
@@ -85,5 +87,13 @@ describe YARD::CLI::YRI do
       @yri.should_receive(:exit).with(1)
       @yri.run('Foo')
     end
+
+    it "should ensure output is serialized" do
+      obj = YARD::CodeObjects::ClassObject.new(:root, 'Foo')
+      class << @yri
+        def test_stub; @serializer.should_receive(:serialize).once end
+      end
+      @yri.run('Foo')
+    end
   end
 end

data/spec/code_objects/proxy_spec.rb

@@ -78,9 +78,26 @@ describe YARD::CodeObjects::Proxy do
     obj.type.should == :class
   end
 
-  it "should retain a type change between Proxy objects" do
+  it "should NOT retain a type change between Proxy objects" do
     P("InvalidClass").type = :class
-    P("InvalidClass").type.should == :class
+    P("InvalidClass").type.should == :proxy
+  end
+
+  it "should use type to ensure resolved object is of intended type" do
+    YARD.parse_string <<-eof
+      module Foo
+        class Bar; end
+        def self.Bar; end
+      end
+    eof
+    proxy = Proxy.new(P('Foo'), 'Bar')
+    proxy.type = :method
+    proxy.path.should == 'Foo.Bar'
+  end
+
+  it "should allow type in initializer" do
+    Proxy.new(Registry.root, 'Foo', :method).type.should == :method
+    P(Registry.root, 'Foo', :method).type.should == :method
   end
 
   it "should never equal Registry.root" do
@@ -113,7 +130,6 @@ describe YARD::CodeObjects::Proxy do
     proxy.type.should == :module
   end
 
-
   it "should handle constant names in namespaces" do
     YARD.parse_string <<-eof
       module A; end; B = A

data/spec/handlers/c/class_handler_spec.rb

@@ -58,7 +58,6 @@ describe YARD::Handlers::C::ClassHandler do
     eof
     Registry.at('Foo::Bar').type.should == :class
     Registry.at('Foo::Bar').superclass.should == P('Bar')
-    P('Bar').should be_a(CodeObjects::Proxy)
-    P('Bar').type.should == :class
+    Registry.at('Foo::Bar').superclass.type.should == :class
   end
 end

data/spec/handlers/c/init_handler_spec.rb

@@ -33,4 +33,15 @@ describe YARD::Handlers::C::InitHandler do
     eof
     Registry.at('A').docstring.should == 'Foo!'
   end
+
+  it "should check non-Init methods for declarations too" do
+    parse(<<-eof)
+      void foo(int x, int y, char *name) {
+        rb_cB = rb_define_class("B", rb_cObject);
+        rb_define_method(rb_cB, "foo", foo_impl, 0);
+      }
+    eof
+    Registry.at('B').should be_a(CodeObjects::ClassObject)
+    Registry.at('B#foo').should be_a(CodeObjects::MethodObject)
+  end
 end