yard 0.6.4 → 0.6.5

data/lib/yard/templates/template.rb

@@ -145,7 +145,7 @@ module YARD
       end
     
       # Loads a template specified by path. If +:template+ or +:format+ is
-      # specified in the {#options} hash, they are prependend and appended
+      # specified in the {#options} hash, they are prepended and appended
       # to the path respectively.
       # 
       # @param [Array<String, Symbol>] path the path of the template

data/spec/cli/config_spec.rb

@@ -1,5 +1,7 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
+require 'yaml'
+
 describe YARD::CLI::Config do
   before do
     @config = YARD::CLI::Config.new
@@ -38,6 +40,24 @@ describe YARD::CLI::Config do
       YARD::Config.options[:load_plugins].should == false
     end
     
+    it "should accept --as-list to force single item as list" do
+      run('--as-list', 'foo', 'bar')
+      YARD::Config.options[:foo].should == ['bar']
+    end
+    
+    it "should accept --append to append values to existing key" do
+      YARD::Config.options[:foo] = ['bar']
+      run('--append', 'foo', 'baz', 'quux')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux']
+      run('-a', 'foo', 'last')
+      YARD::Config.options[:foo].should == ['bar', 'baz', 'quux', 'last']
+    end
+    
+    it "should turn key into list if --append is used on single item" do
+      YARD::Config.options[:foo] = 'bar'
+      run('-a', 'foo', 'baz')
+      YARD::Config.options[:foo].should == ['bar', 'baz']
+    end
     
     it "should modify item if value is given" do
       run('foo', 'xxx')

data/spec/cli/yardoc_spec.rb

@@ -84,6 +84,18 @@ describe YARD::CLI::Yardoc do
       end
     end
     
+    should_accept('--single-db') do |arg|
+      @yardoc.parse_arguments(arg)
+      Registry.single_object_db.should == true
+      Registry.single_object_db = nil
+    end
+
+    should_accept('--no-single-db') do |arg|
+      @yardoc.parse_arguments(arg)
+      Registry.single_object_db.should == false
+      Registry.single_object_db = nil
+    end
+    
     should_accept('-c', '--use-cache') do |arg|
       @yardoc.parse_arguments(arg)
       @yardoc.use_cache.should == true

data/spec/code_objects/base_spec.rb

@@ -226,6 +226,12 @@ describe YARD::CodeObjects::Base do
         Registry.at('A::B').relative_path('A::C')
     end
     
+    it "should return full class name when objects share a common class prefix" do
+      YARD.parse_string "module User; end; module UserManager; end"
+      Registry.at('User').relative_path('UserManager').should == 'UserManager'
+      Registry.at('User').relative_path(Registry.at('UserManager')).should == 'UserManager'
+    end
+    
     it "should return the relative path when they share a common namespace" do
       YARD.parse_string "module A; class B; end; class C; end; end"
       Registry.at('A::B').relative_path(Registry.at('A::C')).should == 'C'
@@ -281,6 +287,13 @@ describe YARD::CodeObjects::Base do
       o.docstring = '(see AnotherObject)'
       o.docstring.should == "FOO"
     end
+
+    it "should not copy docstring mid-docstring" do
+      doc = "Hello.\n(see file.rb)\nmore documentation"
+      o = ClassObject.new(:root, :Me)
+      o.docstring = doc
+      o.docstring.should == doc
+    end
     
     it "should allow extra docstring after (see Path)" do
       ClassObject.new(:root, :AnotherObject) {|x| x.docstring = "FOO" }

data/spec/code_objects/proxy_spec.rb

@@ -112,4 +112,13 @@ describe YARD::CodeObjects::Proxy do
     # Now it should resolve
     proxy.type.should == :module
   end
+  
+  
+  it "should handle constant names in namespaces" do
+    YARD.parse_string <<-eof
+      module A; end; B = A
+      module B::C; def foo; end end
+    eof
+    Proxy.new(:root, 'B::C').should == Registry.at('A::C')
+  end
 end

data/spec/config_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+require 'yaml'
+
 describe YARD::Config do
   describe '.load' do
     before do
@@ -15,7 +17,7 @@ describe YARD::Config do
     
     it "should overwrite options with data in ~/.yard/config" do
       File.should_receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
-      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      File.should_receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
       YAML.should_receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return({'test' => true})
       YARD::Config.load
       YARD::Config.options[:test].should be_true
@@ -90,6 +92,7 @@ describe YARD::Config do
     it "should load gem plugins if :load_plugins is true" do
       File.should_receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
       YARD::Config.stub!(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      YARD::Config.stub!(:load_plugin)
       YARD::Config.should_receive(:require).with('rubygems')
       YARD::Config.load_plugins
     end

data/spec/docstring_spec.rb

@@ -301,5 +301,10 @@ eof
       log.should_receive(:warn).with(/Unknown tag @hello$/)
       Docstring.new("@hello world")
     end
+    
+    it "should not add trailing whitespace to freeform tags" do
+      doc = Docstring.new("@api private   \t   ")
+      doc.tag(:api).text.should == "private"
+    end
   end
 end

data/spec/handlers/alias_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AliasHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AliasHandler" do
   before(:all) { parse_file :alias_handler_001, __FILE__ }
 
   it "should throw alias into namespace object list" do
@@ -55,6 +55,19 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AliasHandler" do
     P(:B).aliases[P('B#x2')].should == :do
   end
   
+  it "should handle quoted symbols" do
+    foo = Registry.at('A#foo')
+    foo.should_not be_nil
+    foo.should be_is_alias
+    Registry.at('A').aliases[foo].should == :a
+  end
+  
+  it "should prepend aliases object's docstring to comments" do
+    Registry.at('D#a').tag(:return).types.should == ['Numeric']
+    Registry.at('D#b').tag(:return).types.should == ['String']
+    Registry.at('D#b').docstring.should == "Foo bar"
+  end
+  
   it "should raise an UndocumentableError if only one parameter is passed" do
     undoc_error "alias_method :q"
   end

data/spec/handlers/attribute_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}AttributeHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandler" do
   before(:all) { parse_file :attribute_handler_001, __FILE__ }
   
   def read_write(namespace, name, read, write, scope = :instance)

data/spec/handlers/base_spec.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/spec_helper'
+require 'ostruct'
 
 include Parser
 
@@ -110,15 +111,15 @@ describe YARD::Handlers::Base do
   end
   
   describe '.in_file' do
-    def parse(filename, src = "class A; end")
-      parser = Parser::SourceParser.new
+    def parse(filename, parser_type, src = "class A; end")
+      parser = Parser::SourceParser.new(parser_type)
       parser.instance_variable_set("@file", filename)
       parser.parse(StringIO.new(src))
     end
     
-    def create_handler(stmts)
+    def create_handler(stmts, parser_type)
       @@counter ||= 0
-      sklass = Parser::SourceParser.parser_type == :ruby ? "Base" : "Legacy::Base"
+      sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
       instance_eval(<<-eof)
         class ::InFileHandler#{@@counter += 1} < Handlers::Ruby::#{sklass}
           handles /^class/
@@ -128,46 +129,45 @@ describe YARD::Handlers::Base do
       eof
     end
     
-    def test_handler(file, stmts, creates = true)
+    def test_handler(file, stmts, creates = true, parser_type = :ruby)
       Registry.clear
       Registry.at('#FOO').should be_nil
-      create_handler(stmts)
-      parse(file)
+      create_handler(stmts, parser_type)
+      parse(file, parser_type)
       Registry.at('#FOO').send(creates ? :should_not : :should, be_nil)
       Handlers::Base.subclasses.delete_if {|k,v| k.to_s =~ /^InFileHandler/ }
     end
     
     [:ruby, :ruby18].each do |parser_type|
-      next if parser_type == :ruby && !RUBY19
+      next if parser_type == :ruby && LEGACY_PARSER
       describe "Parser type = #{parser_type.inspect}" do
-        Parser::SourceParser.parser_type = parser_type
         it "should allow handler to be specific to a file" do
-          test_handler 'file_a.rb', 'in_file "file_a.rb"', true
+          test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
         end
-        
+    
         it "should ignore handler if filename does not match" do
-          test_handler 'file_b.rb', 'in_file "file_a.rb"', false
+          test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
         end
 
         it "should only test filename part when given a String" do
-          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false
+          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
         end
-        
+    
         it "should test exact match for entire String" do
-          test_handler 'file_a.rb', 'in_file "file"', false
+          test_handler 'file_a.rb', 'in_file "file"', false, parser_type
         end
 
         it "should allow a Regexp as argument and test against full path" do
-          test_handler 'file_a.rbx', 'in_file /\.rbx$/', true
-          test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true
-          test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true
+          test_handler 'file_a.rbx', 'in_file /\.rbx$/', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file /\/to\/file_/', true, parser_type
+          test_handler '/path/to/file_a.rbx', 'in_file /^\/path/', true, parser_type
         end
 
         it "should allow multiple in_file declarations" do
           stmts = 'in_file "x"; in_file /y/; in_file "foo.rb"'
-          test_handler 'foo.rb', stmts, true
-          test_handler 'xyzzy.rb', stmts, true
-          test_handler 'x', stmts, true
+          test_handler 'foo.rb', stmts, true, parser_type
+          test_handler 'xyzzy.rb', stmts, true, parser_type
+          test_handler 'x', stmts, true, parser_type
         end
       end
     end

data/spec/handlers/class_condition_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassConditionHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
   before(:all) { parse_file :class_condition_handler_001, __FILE__ }
   
   def verify_method(*names)

data/spec/handlers/class_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
   before(:all) { parse_file :class_handler_001, __FILE__ }
   
   it "should parse a class block with docstring" do

data/spec/handlers/class_variable_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassVariableHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassVariableHandler" do
   before(:all) { parse_file :class_variable_handler_001, __FILE__ }
   
   it "should not parse class variables inside methods" do

data/spec/handlers/constant_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ConstantHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ConstantHandler" do
   before(:all) { parse_file :constant_handler_001, __FILE__ }
   
   it "should not parse constants inside methods" do
@@ -60,5 +60,5 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ConstantHandler" do
   
   it "should raise undocumentable error in 1.9 parser for Struct.new assignment to non-const" do
     undoc_error "nonconst = Struct.new"
-  end if RUBY19
+  end unless LEGACY_PARSER
 end

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

@@ -12,6 +12,9 @@ module A
   alias * a
   alias for a
   alias ConstantName a
+  
+  # Handle quoted symbols
+  alias :'foo' :'a'
 end
 
 class C
@@ -28,3 +31,14 @@ class B < C
   alias do x
   alias x2 do
 end
+
+class D
+  # Foo bar
+  def a; "FOO" end
+  
+  # @return [String]
+  alias b a
+  
+  # @return [Numeric]
+  def a; 0 end
+end

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

@@ -85,3 +85,9 @@ def CONST.meth_on_const; end
 CONST2 = CONST
 def CONST2.meth2_on_const; end
 
+class D
+  alias b a
+  
+  # foo bar
+  def a; end
+end

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

@@ -13,6 +13,7 @@ module A; end
 module Q
 	module A::B
 	end
+	module FOO; end
 end
 
 module ::Kernel
@@ -23,3 +24,6 @@ module A; end
 module B; end
 module C; end
 class D; include A; include B; include C; end
+
+Z = Q
+module Z::FOO::A; end

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

@@ -0,0 +1,8 @@
+module A
+  Foo = 1
+  class B; end
+  module C; end
+  module D; end
+  
+  private_constant :Foo, 'B', C
+end

data/spec/handlers/exception_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ExceptionHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
   before(:all) { parse_file :exception_handler_001, __FILE__ }
   
   it "should not document an exception outside of a method" do

data/spec/handlers/extend_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ExtendHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
   before(:all) { parse_file :extend_handler_001, __FILE__ }
 
   it "should include modules at class scope" do

data/spec/handlers/method_condition_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MethodConditionHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodConditionHandler" do
   before(:all) { parse_file :method_condition_handler_001, __FILE__ }
   
   it "should not parse regular if blocks in methods" do

data/spec/handlers/method_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MethodHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler" do
   before(:all) do
     log.enter_level(Logger::ERROR) do
       parse_file :method_handler_001, __FILE__ 
@@ -132,4 +132,10 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MethodHandler" do
     Registry.at('Foo.meth_on_const').should_not be_nil
     Registry.at('Foo.meth2_on_const').should_not be_nil
   end
+  
+  it "should copy alias information on method (re-)definition to new method" do
+    Registry.at('D').aliases.should be_empty
+    Registry.at('D#b').is_alias?.should == false
+    Registry.at('D#a').is_alias?.should == false
+  end
 end

data/spec/handlers/mixin_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MixinHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler" do
   before(:all) { parse_file :mixin_handler_001, __FILE__ }
   
   it "should handle includes from classes or modules" do

data/spec/handlers/module_handler_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ModuleHandler" do
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
   before(:all) { parse_file :module_handler_001, __FILE__ }
 
   it "should parse a module block" do
@@ -27,4 +27,8 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ModuleHandler" do
   it "should list mixins in proper order" do
     Registry.at('D').mixins.should == [P(:C), P(:B), P(:A)]
   end
+  
+  it "should create proper module when constant is in namespace" do
+    Registry.at('Q::FOO::A').should_not be_nil
+  end
 end