yard 0.5.4 → 0.5.5

data/lib/yard/code_objects/base.rb

@@ -254,7 +254,7 @@ module YARD
           super
         end
       end
-      
+
       # Accesses a custom attribute on the object
       # @param [#to_s] key the name of the custom attribute
       # @return [Object, nil] the custom attribute or nil if not found.

data/lib/yard/code_objects/class_object.rb

@@ -45,7 +45,7 @@ module YARD::CodeObjects
       [self] + list.map do |m|
         next m unless m.respond_to?(:inheritance_tree)
         m.inheritance_tree(include_mods)
-      end.flatten
+      end.flatten.uniq
     end
     
     # Returns the list of methods matching the options hash. Returns

data/lib/yard/code_objects/module_object.rb

@@ -12,7 +12,7 @@ module YARD::CodeObjects
         next if m == self
         next m unless m.respond_to?(:inheritance_tree)
         m.inheritance_tree(true)
-      end.compact.flatten
+      end.compact.flatten.uniq
     end
   end
 end

data/lib/yard/code_objects/proxy.rb

@@ -127,7 +127,7 @@ module YARD
           false
         end
       end
-      
+
       # Returns the class name of the object the proxy is mimicking, if
       # resolved. Otherwise returns +Proxy+. 
       # @return [Class] the resolved object's class or +Proxy+

data/lib/yard/docstring.rb

@@ -149,8 +149,8 @@ module YARD
     end
     
     # Creates a {Tags::RefTag}
-    def create_ref_tag(tag_name, name, object)
-      @ref_tags << Tags::RefTagList.new(tag_name, object, name)
+    def create_ref_tag(tag_name, name, object_name)
+      @ref_tags << Tags::RefTagList.new(tag_name, P(object, object_name), name)
     end
     
     # Creates a tag from the {Tags::DefaultFactory tag factory}.

data/lib/yard/handlers/ruby/constant_handler.rb

@@ -39,8 +39,8 @@ class YARD::Handlers::Ruby::ConstantHandler < YARD::Handlers::Ruby::Base
       name = node.jump(:ident).source
       klass.attributes[scope][name] = SymbolHash[:read => nil, :write => nil]
       {read: name, write: "#{name}="}.each do |type, meth|
-        klass.attributes[scope][name][type] = MethodObject.new(klass, meth, scope)
+        klass.attributes[scope][name][type] = register MethodObject.new(klass, meth, scope)
       end
     end
   end
-end
+end

data/lib/yard/handlers/ruby/legacy/class_condition_handler.rb

@@ -1,8 +1,71 @@
 class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < YARD::Handlers::Ruby::Legacy::Base
   namespace_only
-  handles TkIF, TkELSIF, TkELSE, TkUNLESS
+  handles TkIF, TkELSIF, TkUNLESS
   
   process do
+    condition = parse_condition
+    if condition == nil
+      # Parse both blocks if we're unsure of the condition
+      parse_then_block
+      parse_else_block
+    elsif condition
+      parse_then_block
+    else
+      parse_else_block
+    end
+  end
+  
+  protected
+  
+  # Parses the condition part of the if/unless statement
+  # 
+  # @return [true, false, nil] true if the condition can be definitely
+  #   parsed to true, false if not, and nil if the condition cannot be
+  #   parsed with certainty (it's dynamic)
+  def parse_condition
+    condition = nil
+    
+    # Right now we can handle very simple unary conditions like:
+    #   if true
+    #   if false
+    #   if 0
+    #   if 100 (not 0)
+    #   if defined? SOME_CONSTANT
+    # 
+    # The last case will do a lookup in the registry and then one
+    # in the Ruby world (using eval).
+    case statement.tokens[1..-1].to_s.strip
+    when /^(\d+)$/
+      condition = $1 != "0"
+    when /^defined\?\s*\(?(.+?)\)?$/
+      # defined? keyword used, let's see if we can look up the name
+      # in the registry, then we'll try using Ruby's powers. eval() is not
+      # *too* dangerous here since code is not actually executed.
+      name = $1
+      obj = YARD::Registry.resolve(namespace, name, true)
+      condition = true if obj || Object.instance_eval("defined? #{name}")
+    when "true"
+      condition = true
+    when "false"
+      condition = false
+    end
+    
+    if TkUNLESS === statement.tokens.first
+      condition = !condition if condition != nil
+    end
+    condition
+  end
+  
+  def parse_then_block
     parse_block
   end
+  
+  def parse_else_block
+    stmtlist = YARD::Parser::Ruby::Legacy::StatementList
+    stmtlist.new(statement.block).each do |stmt|
+      if TkELSE === stmt.tokens.first
+        parser.process(stmtlist.new(stmt.block))
+      end
+    end
+  end
 end

data/lib/yard/handlers/ruby/legacy/constant_handler.rb

@@ -25,8 +25,8 @@ class YARD::Handlers::Ruby::Legacy::ConstantHandler < YARD::Handlers::Ruby::Lega
     tokval_list(YARD::Parser::Ruby::Legacy::TokenList.new(parameters), TkSYMBOL).each do |name|
       klass.attributes[scope][name] = SymbolHash[:read => nil, :write => nil]
       {:read => name, :write => "#{name}="}.each do |type, meth|
-        klass.attributes[scope][name][type] = MethodObject.new(klass, meth, scope)
+        klass.attributes[scope][name][type] = register MethodObject.new(klass, meth, scope)
       end
     end
   end
-end
+end

data/lib/yard/handlers/ruby/legacy/method_handler.rb

@@ -42,6 +42,17 @@ class YARD::Handlers::Ruby::Legacy::MethodHandler < YARD::Handlers::Ruby::Legacy
       end
     end
     
+    if obj.has_tag?(:option)
+      # create the options parameter if its missing
+      obj.tags(:option).each do |option|
+        expected_param = option.name
+        unless obj.tags(:param).find {|x| x.name == expected_param }
+          new_tag = YARD::Tags::Tag.new(:param, "a customizable set of options", "Hash", expected_param)
+          obj.docstring.add_tag(new_tag)
+        end
+      end
+    end
+    
     if info = obj.attr_info
       if meth.to_s =~ /=$/ # writer
         info[:write] = obj if info[:read]

data/lib/yard/handlers/ruby/method_handler.rb

@@ -39,6 +39,17 @@ class YARD::Handlers::Ruby::MethodHandler < YARD::Handlers::Ruby::Base
       end
     end
     
+    if obj.has_tag?(:option)
+      # create the options parameter if its missing
+      obj.tags(:option).each do |option|
+        expected_param = option.name
+        unless obj.tags(:param).find {|x| x.name == expected_param }
+          new_tag = YARD::Tags::Tag.new(:param, "a customizable set of options", "Hash", expected_param)
+          obj.docstring.add_tag(new_tag)
+        end
+      end
+    end
+    
     if info = obj.attr_info
       if meth.to_s =~ /=$/ # writer
         info[:write] = obj if info[:read]

data/lib/yard/parser/ruby/legacy/statement_list.rb

@@ -6,7 +6,7 @@ module YARD
       # The following list of tokens will require a block to be opened 
       # if used at the beginning of a statement.
       OPEN_BLOCK_TOKENS = [TkCLASS, TkDEF, TkMODULE, TkUNTIL,
-                           TkIF, TkUNLESS, TkWHILE, TkFOR, TkCASE]
+                           TkIF, TkELSIF, TkUNLESS, TkWHILE, TkFOR, TkCASE]
 
       ##
       # Creates a new statement list
@@ -215,7 +215,7 @@ module YARD
       #
       # @param [RubyToken::Token] tk the token to process
       def process_simple_block_opener(tk)
-        return unless [TkLBRACE, TkDO, TkBEGIN].include?(tk.class) &&
+        return unless [TkLBRACE, TkDO, TkBEGIN, TkELSE].include?(tk.class) &&
           # Make sure hashes are parsed as hashes, not as blocks
           (@last_ns_tk.nil? || @last_ns_tk.lex_state != EXPR_BEG)
 
@@ -314,7 +314,7 @@ module YARD
         if [TkLPAREN, TkLBRACK, TkLBRACE, TkDO, TkBEGIN].include?(tk.class)
           @level += 1
         elsif OPEN_BLOCK_TOKENS.include?(tk.class)
-          @level += 1 unless @last_ns_tk.class == TkALIAS
+          @level += 1 unless @last_ns_tk.class == TkALIAS || tk.class == TkELSIF
         elsif [TkRPAREN, TkRBRACK, TkRBRACE, TkEND].include?(tk.class) && @level > 0
           @level -= 1
         end

data/lib/yard/parser/source_parser.rb

@@ -149,8 +149,8 @@ module YARD
       def parse(content = __FILE__)
         case content
         when String
-          @file = content
-          content = convert_encoding(File.read_binary(content))
+          @file = File.cleanpath(content)
+          content = convert_encoding(File.read_binary(file))
           checksum = Registry.checksum_for(content)
           return if Registry.checksums[file] == checksum
 

data/lib/yard/tags/default_factory.rb

@@ -110,20 +110,20 @@ module YARD
         [title, desc]
       end
       
-      # Parses a [], <>, {} or () block at the beginning of a line of text into a list of
-      # comma delimited values. Returns the text be
+      # Parses a [], <>, {} or () block at the beginning of a line of text 
+      # into a list of comma delimited values.
       # 
       # @example
       #   obj.parse_types('[String, Array<Hash, String>, nil]') # => [nil, ['String', 'Array<Hash, String>', 'nil'], ""]
       #   obj.parse_types('b<String> A string') # => ['b', ['String'], 'A string']
       # 
-      # @return [String, Array<String>] the text before the type list (or nil), followed by the type list parsed
-      #   into an array of strings, followed by the text following the type list.
-      # @return [nil] if no type list is present.
+      # @return [Array(String, Array<String>, String)] the text before the type 
+      #   list (or nil), followed by the type list parsed into an array of 
+      #   strings, followed by the text following the type list.
       def extract_types_and_name_from_text(text, opening_types = TYPELIST_OPENING_CHARS, closing_types = TYPELIST_CLOSING_CHARS)
         s, e = 0, 0
         before = ''
-        list, level = [''], 0
+        list, level, seen_space = [''], 0, false
         text.split(//).each_with_index do |c, i|
           if opening_types.include?(c)
             list.last << c if level > 0
@@ -136,7 +136,10 @@ module YARD
           elsif c == ',' && level == 1
             list.push ''
           elsif c =~ /\S/ && level == 0
+            break e = i if seen_space && list == ['']
             before << c
+          elsif c =~ /\s/ && level == 0 && !before.empty?
+            seen_space = true
           elsif level >= 1
             list.last << c
           end

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

@@ -14,9 +14,15 @@ module YARD::Templates::Helpers
     end
     
     def linkify(*args) 
-      # The :// character sequence exists in no valid object path but just about every URL scheme.
-      if args.first.is_a?(String) && args.first.include?("://")
-        link_url(*args)
+      if args.first.is_a?(String)
+        case args.first
+        when %r{://}, /^mailto:/
+          link_url(args[0], args[1], {:target => '_parent'}.merge(args[2]||{}))
+        when /^file:(\S+?)(?:#(\S+))?$/
+          link_file($1, args[1] ? args[1] : $1, $2)
+        else
+          link_object(*args)
+        end
       else
         link_object(*args)
       end
@@ -35,10 +41,14 @@ module YARD::Templates::Helpers
       end
     end
     
-    def link_url(url)
+    def link_url(url, title = nil, params = nil)
       url
     end
     
+    def link_file(filename, title = nil, anchor = nil)
+      filename
+    end
+    
     def format_types(list, brackets = true)
       list.nil? || list.empty? ? "" : (brackets ? "(#{list.join(", ")})" : list.join(", "))
     end

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

@@ -122,33 +122,27 @@ module YARD
       def resolve_links(text)
         code_tags = 0
         text.gsub(/<(\/)?(pre|code|tt)|\{(\S+?)(?:\s(.*?\S))?\}(?=[\W<]|.+<\/|$)/) do |str|
-          tag = $2
-          closed = $1
+          closed, tag, name, title = $1, $2, $3, $4
           if tag
             code_tags += (closed ? -1 : 1)
             next str
           end
           next str unless code_tags == 0
           
-          name = $3
-          title = $4 || name
-
-          case name
-          when %r{://}, /^mailto:/
-            link_url(name, title, :target => '_parent')
-          when /^file:(\S+?)(?:#(\S+))?$/
-            link_file($1, title == name ? $1 : title, $2)
+          if object.is_a?(String)
+            object
           else
-            if object.is_a?(String)
-              obj = name
+            link = linkify(name, title)
+            if link == name || link == title
+              match = text[/(.{0,20}\{.*?#{Regexp.quote name}.*?\}.{0,20})/, 1]
+              log.warn "In file `#{object.file}':#{object.line}: Cannot resolve link to #{name} from text" + (match ? ":" : ".")
+              log.warn '...' + match.gsub(/\n/,"\n\t") + '...' if match
+            end
+            
+            if name =~ %r{://} || name =~ /^(mailto|file):/
+              link
             else
-              obj = Registry.resolve(object, name, true, true)
-              if obj.is_a?(CodeObjects::Proxy)
-                match = text[/(.{0,20}\{.*?#{Regexp.quote name}.*?\}.{0,20})/, 1]
-                log.warn "In file `#{object.file}':#{object.line}: Cannot resolve link to #{obj.path} from text" + (match ? ":" : ".")
-                log.warn '...' + match.gsub(/\n/,"\n\t") + '...' if match
-              end
-              "<tt>" + linkify(obj, title) + "</tt>" 
+              "<tt>" + link + "</tt>"
             end
           end
         end
@@ -199,17 +193,17 @@ module YARD
           title = h(obj.to_s)
         end
         return title unless serializer
-
         return title if obj.is_a?(CodeObjects::Proxy)
-      
+              
         link = url_for(obj, anchor, relative)
         link ? link_url(link, title, :title => "#{obj.path} (#{obj.type})") : title
       end
       
       def link_url(url, title = nil, params = {})
+        title ||= url
         params = SymbolHash.new(false).update(
           :href => url,
-          :title  => h(title || url)
+          :title  => h(title)
         ).update(params)
         "<a #{tag_attrs(params)}>#{title}</a>"
       end

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

@@ -6,7 +6,7 @@ module YARD
         params = object.parameters
         if object.has_tag?(:yield) || object.has_tag?(:yieldparam)
           params.reject! do |param|
-            param[0][0,1] == "&" && 
+            param[0].to_s[0,1] == "&" &&
               !object.tags(:param).any? {|t| t.name == param[0][1..-1] }
           end
         end

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

@@ -4,7 +4,6 @@ module YARD
       module ModuleHelper
         def prune_method_listing(list, hide_attributes = true)
           list = run_verifier(list)
-          list = list.reject {|o| !options[:visibilities].include? o.visibility } if options[:visibilities]
           list = list.reject {|o| o.is_alias? unless CodeObjects::Proxy === o.namespace }
           list = list.reject {|o| o.is_attribute? unless CodeObjects::Proxy === o.namespace } if hide_attributes
           list
@@ -12,4 +11,4 @@ module YARD
       end
     end
   end
-end
+end

data/spec/cli/yardoc_spec.rb

@@ -41,7 +41,7 @@ describe YARD::CLI::Yardoc do
 
   it "should use String#shell_split to split .yardopts tokens" do
     optsdata = "foo bar"
-    optsdata.should_receive(:shell_split)
+    optsdata.should_receive(:shell_split).and_return([optsdata])
     IO.should_receive(:read).with("test").and_return(optsdata)
     @yardoc.stub!(:support_rdoc_document_file!).and_return([])
     @yardoc.options_file = "test"

data/spec/code_objects/class_object_spec.rb

@@ -6,6 +6,7 @@ describe YARD::CodeObjects::ClassObject do
       Registry.clear
       @mixin = ModuleObject.new(:root, :SomeMixin)
       @mixin2 = ModuleObject.new(:root, :SomeMixin2)
+      @mixin2.instance_mixins << @mixin
       @mixin3 = ModuleObject.new(:root, :SomeMixin3)
       @mixin4 = ModuleObject.new(:root, :SomeMixin4)
       @mixin2.instance_mixins << @mixin3

data/spec/code_objects/module_object_spec.rb

@@ -111,6 +111,7 @@ describe YARD::CodeObjects::ModuleObject do
 
       @mod1.instance_mixins << @mod2
       @mod2.instance_mixins << @mod3
+      @mod3.instance_mixins << @mod4
       @mod1.instance_mixins << @mod4
     
       @proxy = P(:SomeProxyClass)

data/spec/docstring_spec.rb

@@ -117,6 +117,20 @@ describe YARD::Docstring do
       tags = doc.tags('param')
       tags.size.should == 0
     end
+    
+    it "resolves references to methods in the same class with #methname" do
+      klass = CodeObjects::ClassObject.new(:root, "Foo")
+      o = CodeObjects::MethodObject.new(klass, "bar")
+      ref = CodeObjects::MethodObject.new(klass, "baz")
+      o.docstring.add_tag Tags::Tag.new('param', 'testing', nil, 'arg1')
+      ref.docstring = "@param (see #bar)"
+      
+      tags = ref.docstring.tags("param")
+      tags.size.should == 1
+      tags.first.text.should == "testing"
+      tags.first.should be_kind_of(Tags::RefTag)
+      tags.first.owner.should == o
+    end
   end
   
   describe '#empty?/#blank?' do

data/spec/handlers/class_condition_handler_spec.rb

@@ -32,17 +32,15 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassConditionHandler
     verify_method :j, :k
   end
   
-  if RUBY19
-    it "should parse all if/elsif blocks for complex conditions" do
-      verify_method :a, :b, :c, :d
-    end
+  it "should parse all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
 
-    it "should only parse else block if condition is literal value `false`" do
-      verify_method :q
-    end
+  it "should only parse else block if condition is literal value `false`" do
+    verify_method :q
+  end
 
-    it "should only parse else block if condition is literal integer == 0" do
-      verify_method :n
-    end
+  it "should only parse else block if condition is literal integer == 0" do
+    verify_method :n
   end
 end