yard 0.5.8 → 0.6.0

data/spec/cli/diff_spec.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+require 'open-uri'
+
+describe YARD::CLI::Diff do
+  before do
+    CLI::Yardoc.stub!(:run)
+    CLI::Gems.stub!(:run)
+    @diff = CLI::Diff.new
+  end
+  
+  describe 'Argument handling' do
+    it "should exit if there is only one gem name" do
+      @diff.should_receive(:exit)
+      @diff.should_receive(:puts).with(/Usage/)
+      @diff.run
+    end
+  end
+  
+  describe 'Diffing' do
+    before do
+      @objects1 = nil
+      @objects2 = nil
+    end
+
+    def run(*args)
+      @data = StringIO.new
+      @objects1 ||= %w( C#fooey C#baz D.bar )
+      @objects2 ||= %w( A A::B A::B::C A.foo A#foo B C.foo C.bar C#baz )
+      @diff.should_receive(:load_gem_data).ordered.with('gem1').and_return(true)
+      @diff.should_receive(:load_gem_data).ordered.with('gem2').and_return(true)
+      Registry.should_receive(:all).ordered.and_return(@objects1.map {|o| P(o) })
+      Registry.should_receive(:all).ordered.and_return(@objects2.map {|o| P(o) })
+      @diff.stub!(:print).with {|data| @data << data }
+      @diff.stub!(:puts).with {|*args| @data << args.join("\n"); @data << "\n" }
+      @diff.run(*(args + ['gem1', 'gem2']))
+    end
+
+    it "should show differences between objects" do
+      run
+      @data.string.should == <<-eof
+Added objects:
+
+  A (...)
+  B
+  C.bar
+  C.foo
+
+Removed objects:
+
+  C#fooey
+  D.bar
+
+eof
+    end
+
+    it "should accept -a/--all" do
+      ['-a', '--all'].each do |opt|
+        run(opt)
+        @data.string.should == <<-eof
+Added objects:
+
+  A
+  A#foo
+  A.foo
+  A::B
+  A::B::C
+  B
+  C.bar
+  C.foo
+
+Removed objects:
+
+  C#fooey
+  D.bar
+
+eof
+      end
+    end
+  end
+  
+  describe 'File searching' do
+    before do
+      @diff.stub!(:generate_yardoc)
+    end
+    
+    it "should search for gem/.yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(true)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1/.yardoc')
+      Registry.should_receive(:load_yardoc).with('gem2/.yardoc')
+      @diff.run('gem1', 'gem2')
+    end
+    
+    it "should search for argument as yardoc" do
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(true)
+      File.should_receive(:directory?).with('gem2').and_return(true)
+      Registry.should_receive(:load_yardoc).with('gem1')
+      Registry.should_receive(:load_yardoc).with('gem2')
+      @diff.run('gem1', 'gem2')
+    end
+
+    it "should search for installed gem" do
+      File.should_receive(:directory?).with('gem1-1.0.0.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1-1.0.0.gem').and_return(false)
+      File.should_receive(:directory?).with('gem2-1.0.0').and_return(false)
+      gemmock = mock(:gemmock)
+      spec1 = mock(:spec)
+      spec2 = mock(:spec)
+      gemmock.should_receive(:find_name).at_least(1).times.and_return([spec1, spec2])
+      Gem.should_receive(:source_index).at_least(1).times.and_return(gemmock)
+      spec1.stub!(:full_name).and_return('gem1-1.0.0')
+      spec1.stub!(:name).and_return('gem1')
+      spec1.stub!(:version).and_return('1.0.0')
+      spec2.stub!(:full_name).and_return('gem2-1.0.0')
+      spec2.stub!(:name).and_return('gem2')
+      spec2.stub!(:version).and_return('1.0.0')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem1', '= 1.0.0').and_return('/path/to/file')
+      Registry.should_receive(:yardoc_file_for_gem).with('gem2', '= 1.0.0').and_return(nil)
+      Registry.should_receive(:load_yardoc).with('/path/to/file')
+      CLI::Gems.should_receive(:run).with('gem2', '1.0.0').and_return(nil)
+      Dir.stub!(:chdir)
+      @diff.run('gem1-1.0.0.gem', 'gem2-1.0.0')
+    end
+    
+    it "should search for .gem file" do
+      iomock = mock(:io)
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(true)
+      File.should_receive(:exist?).with('gem2.gem').and_return(true)
+      File.should_receive(:open).with('gem1.gem', 'rb').and_yield(iomock)
+      File.should_receive(:open).with('gem2.gem', 'rb')
+      FileUtils.should_receive(:mkdir_p)
+      Gem::Package.should_receive(:open).with(iomock)
+      FileUtils.should_receive(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+    
+    it "should search for .gem file on rubygems.org" do
+      iomock = mock(:io)
+      File.should_receive(:directory?).with('gem1/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem/.yardoc').and_return(false)
+      File.should_receive(:directory?).with('gem1').and_return(false)
+      File.should_receive(:directory?).with('gem2.gem').and_return(false)
+      File.should_receive(:directory?).any_number_of_times
+      File.should_receive(:exist?).with('gem1.gem').and_return(false)
+      File.should_receive(:exist?).with('gem2.gem').and_return(false)
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem1.gem').and_yield(iomock)
+      @diff.should_receive(:open).with('http://rubygems.org/downloads/gem2.gem')
+      FileUtils.should_receive(:mkdir_p)
+      Gem::Package.should_receive(:open).with(iomock)
+      FileUtils.should_receive(:rm_rf)
+      @diff.run('gem1', 'gem2.gem')
+    end
+    
+    it "should error if gem is not found" do
+      log.should_receive(:error).with("Cannot find gem gem1")
+      log.should_receive(:error).with("Cannot find gem gem2.gem")
+      @diff.stub!(:load_gem_data).and_return(false)
+      @diff.run('gem1', 'gem2.gem')
+    end
+  end
+end

data/spec/cli/help_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Help do
+  describe '#run' do
+    it "should accept 'help command'" do
+      CLI::Yardoc.should_receive(:run).with('--help')
+      CLI::Help.run('doc')
+    end
+    
+    it "should accept no arguments (lists all commands)" do
+      CLI::CommandParser.should_receive(:run).with('--help')
+      CLI::Help.run
+    end
+    
+    it "should show all commands if command isn't found" do
+      CLI::CommandParser.should_receive(:run).with('--help')
+      help = CLI::Help.new
+      help.should_receive(:puts).with(/not found/)
+      help.run('unknown')
+    end
+  end
+end

data/spec/cli/server_spec.rb

@@ -0,0 +1,140 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe YARD::CLI::Server do
+  before do
+    @no_verify_libraries = false
+    @libraries = {}
+    @options = {:single_library => true, :caching => false}
+    @server_options = {:Port => 8808}
+    @adapter = mock(:adapter)
+    @cli = YARD::CLI::Server.new
+    @cli.stub!(:adapter).and_return(@adapter)
+  end
+  
+  def rack_required
+    begin; require 'rack'; rescue LoadError; pending "rack required for this test" end
+  end
+  
+  def run(*args)
+    if @libraries.empty?
+      library = Server::LibraryVersion.new(File.basename(Dir.pwd), nil, '.yardoc')
+      @libraries = {library.name => [library]}
+    end
+    unless @no_verify_libraries
+      @libraries.values.each {|libs| libs.each {|lib| File.should_receive(:exist?).at_least(1).times.with(lib.yardoc_file).and_return(true) } }
+    end
+    @adapter.should_receive(:new).with(@libraries, @options, @server_options).and_return(@adapter)
+    @adapter.should_receive(:start)
+    @cli.run(*args.flatten)
+  end
+
+  it "should default to current dir if no library is specified" do
+    Dir.should_receive(:pwd).and_return('/path/to/foo')
+    @libraries['foo'] = [Server::LibraryVersion.new('foo', nil, '.yardoc')]
+    run
+  end
+  
+  it "should use .yardoc as yardoc file is library list is odd" do
+    @libraries['a'] = [Server::LibraryVersion.new('a', nil,'.yardoc')]
+    run 'a'
+  end
+  
+  it "should force multi library if more than one library is listed" do
+    @options[:single_library] = false
+    @libraries['a'] = [Server::LibraryVersion.new('a', nil, 'b')]
+    @libraries['c'] = [Server::LibraryVersion.new('c', nil, '.yardoc')]
+    run %w(a b c)
+  end
+  
+  it "should accept -m, --multi-library" do
+    @options[:single_library] = false
+    run '-m'
+    run '--multi-library'
+  end
+  
+  it "should accept -c, --cache" do
+    @options[:caching] = true
+    run '-c'
+    run '--cache'
+  end
+  
+  it "should accept -r, --reload" do
+    @options[:incremental] = true
+    run '-r'
+    run '--reload'
+  end
+  
+  it "should accept -d, --daemon" do
+    @server_options[:daemonize] = true
+    run '-d'
+    run '--daemon'
+  end
+  
+  it "should accept -p, --port" do
+    @server_options[:Port] = 10
+    run '-p', '10'
+    run '--port', '10'
+  end
+  
+  it "should accept --docroot" do
+    @server_options[:DocumentRoot] = '/foo/bar'
+    run '--docroot', '/foo/bar'
+  end
+  
+  it "should accept -a webrick to create WEBrick adapter" do
+    @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+    run '-a', 'webrick'
+  end
+  
+  it "should accept -a rack to create Rack adapter" do
+    rack_required
+    @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+    run '-a', 'rack'
+  end
+  
+  it "should default to Rack adapter if exists on system" do
+    rack_required
+    @cli.unstub(:adapter)
+    @cli.should_receive(:require).with('rubygems').and_return(false)
+    @cli.should_receive(:require).with('rack').and_return(true)
+    @cli.should_receive(:adapter=).with(YARD::Server::RackAdapter)
+    @cli.send(:select_adapter)
+  end
+
+  it "should fall back to WEBrick adapter if Rack is not on system" do
+    @cli.unstub(:adapter)
+    @cli.should_receive(:require).with('rubygems').and_return(false)
+    @cli.should_receive(:require).with('rack').and_raise(LoadError)
+    @cli.should_receive(:adapter=).with(YARD::Server::WebrickAdapter)
+    @cli.send(:select_adapter)
+  end
+  
+  it "should accept -s, --server" do
+    @server_options[:server] = 'thin'
+    run '-s', 'thin'
+    run '--server', 'thin'
+  end
+  
+  it "should accept -g, --gems" do
+    @no_verify_libraries = true
+    @options[:single_library] = false
+    @libraries['gem1'] = [Server::LibraryVersion.new('gem1', '1.0.0', nil, :gem)]
+    @libraries['gem2'] = [Server::LibraryVersion.new('gem2', '1.0.0', nil, :gem)]
+    gem1 = mock(:gem1)
+    gem1.stub!(:name).and_return('gem1')
+    gem1.stub!(:version).and_return('1.0.0')
+    gem1.stub!(:full_gem_path).and_return('/path/to/foo')
+    gem2 = mock(:gem2)
+    gem2.stub!(:name).and_return('gem2')
+    gem2.stub!(:version).and_return('1.0.0')
+    gem2.stub!(:full_gem_path).and_return('/path/to/bar')
+    specs = {'gem1' => gem1, 'gem2' => gem2}
+    source = mock(:source_index)
+    source.stub!(:find_name).and_return do |k, ver|
+      k == '' ? specs.values : specs.grep(k).map {|name| specs[name] }
+    end
+    Gem.stub!(:source_index).and_return(source)
+    run '-g'
+    run '--gems'
+  end
+end

data/spec/cli/stats_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+
+describe YARD::CLI::Stats do
+  before do
+    Registry.clear
+    YARD.parse_string <<-eof
+      class A
+        CONST = 1
+        
+        def foo; end
+        
+        # Documented
+        def bar; end
+      end
+      module B; end
+    eof
+    
+    @main_stats = 
+      "Files:           1\n" +
+      "Modules:         1 (    1 undocumented)\n" +
+      "Classes:         1 (    1 undocumented)\n" +
+      "Constants:       1 (    1 undocumented)\n" +
+      "Methods:         2 (    1 undocumented)\n" +
+      " 20.00% documented\n"
+    
+    @output = StringIO.new
+    @stats = CLI::Stats.new(false)
+    @stats.stub!(:support_rdoc_document_file!).and_return([])
+    @stats.stub!(:yardopts).and_return([])
+    @stats.stub!(:puts).with {|*args| @output << args.join("\n") << "\n" }
+  end
+  
+  it "should list undocumented objects with --list-undoc" do
+    @stats.run('--list-undoc')
+    @output.string.should == <<-eof
+#{@main_stats}
+Undocumented Objects:
+
+(in file: (stdin))
+B
+A
+A::CONST
+A#foo
+eof
+  end
+  
+  it "should list undocumented objects in compact mode with --list-undoc --compact" do
+    @stats.run('--list-undoc', '--compact')
+    @output.string.should == <<-eof
+#{@main_stats}
+Undocumented Objects:
+B            ((stdin))
+A            ((stdin))
+A::CONST     ((stdin))
+A#foo        ((stdin))
+eof
+  end
+  
+  it "should still list stats with --quiet" do
+    @stats.run('--quiet')
+    @output.string.should == @main_stats
+  end
+  
+  it "should not include public methods in stats with --no-public" do
+    @stats.run('--no-public')
+    @output.string.should == 
+      "Files:           1\n" +
+      "Modules:         1 (    1 undocumented)\n" +
+      "Classes:         1 (    1 undocumented)\n" +
+      "Constants:       1 (    1 undocumented)\n" +
+      "Methods:         0 (    0 undocumented)\n" +
+      " 0.00% documented\n"
+  end
+end

data/spec/cli/yardoc_spec.rb

@@ -1,214 +1,470 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-class YARD::CLI::Yardoc; public :optparse end
-
 describe YARD::CLI::Yardoc do
   before do
     @yardoc = YARD::CLI::Yardoc.new
-    @yardoc.stub!(:generate).and_return(false)
+    @yardoc.statistics = false
+    @yardoc.use_document_file = false
+    @yardoc.use_yardopts_file = false
+    @yardoc.generate = false
     Templates::Engine.stub!(:render)
     Templates::Engine.stub!(:generate)
     YARD.stub!(:parse)
   end
   
-  it "should accept --title" do
-    @yardoc.optparse('--title', 'hello world')
-    @yardoc.options[:title].should == 'hello world'
+  describe 'Defaults' do
+    before do
+      @yardoc = CLI::Yardoc.new
+      @yardoc.stub!(:yardopts).and_return([])
+      @yardoc.stub!(:support_rdoc_document_file!).and_return([])
+      @yardoc.parse_arguments
+    end
+    
+    it "should use cache by default" do
+      @yardoc.use_cache.should == false
+    end
+    
+    it "print statistics by default" do
+      @yardoc.statistics.should == true
+    end
+    
+    it "should generate output by default" do
+      @yardoc.generate.should == true
+    end
+    
+    it "should read .yardopts by default" do
+      @yardoc.use_yardopts_file.should == true
+    end
+    
+    it "should read .document by default" do
+      @yardoc.use_document_file.should == true
+    end
+    
+    it "should use lib/**/*.rb and ext/**/*.c as default file glob" do
+      @yardoc.files.should == ['lib/**/*.rb', 'ext/**/*.c']
+    end
+    
+    it "should use rdoc as default markup type" do
+      @yardoc.options[:markup].should == :rdoc
+    end
+    
+    it "should use default as default template" do
+      @yardoc.options[:template].should == :default
+    end
+    
+    it "should use HTML as default format" do
+      @yardoc.options[:format].should == :html
+    end
+    
+    it "should use 'Object' as default return type" do
+      @yardoc.options[:default_return].should == 'Object'
+    end
+    
+    it "should not hide void return types by default" do
+      @yardoc.options[:hide_void_return].should == false
+    end
+    
+    it "should only show public visibility by default" do
+      @yardoc.visibilities.should == [:public]
+    end
+    
+    it "should not list objects by default" do
+      @yardoc.list.should == false
+    end
   end
+  
+  describe 'General options' do
+    def self.should_accept(*args, &block)
+      @counter ||= 0
+      @counter += 1
+      counter = @counter
+      args.each do |arg| 
+        define_method("test_options_#{@counter}", &block)
+        it("should accept #{arg}") { send("test_options_#{counter}", arg) }
+      end
+    end
+    
+    should_accept('-c', '--use-cache') do |arg|
+      @yardoc.parse_arguments(arg)
+      @yardoc.use_cache.should == true
+    end
+    
+    should_accept('--no-cache') do |arg|
+      @yardoc.parse_arguments(arg)
+      @yardoc.use_cache.should == false
+    end
+    
+    should_accept('--yardopts') do |arg|
+      @yardoc = CLI::Yardoc.new
+      @yardoc.use_document_file = false
+      @yardoc.should_receive(:yardopts).and_return([])
+      @yardoc.parse_arguments('--no-yardopts', arg)
+      @yardoc.use_yardopts_file.should == true
+    end
 
-  it "should alias --main to the --readme flag" do
-    readme = File.join(File.dirname(__FILE__),'..','..','README.md')
+    should_accept('--no-yardopts') do |arg|
+      @yardoc = CLI::Yardoc.new
+      @yardoc.use_document_file = false
+      @yardoc.should_not_receive(:yardopts)
+      @yardoc.parse_arguments('--yardopts', arg)
+      @yardoc.use_yardopts_file.should == false
+    end
 
-    @yardoc.optparse('--main', readme)
-    @yardoc.options[:readme].should == readme
-  end
-  
-  it "should select a markup provider when --markup-provider or -mp is set" do
-    @yardoc.optparse("-M", "test")
-    @yardoc.options[:markup_provider].should == :test
-    @yardoc.optparse("--markup-provider", "test2")
-    @yardoc.options[:markup_provider].should == :test2
-  end
-  
-  it "should search for and use yardopts file specified by #options_file" do
-    File.should_receive(:read_binary).with("test").and_return("-o \n\nMYPATH\nFILE1 FILE2")
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.options_file = "test"
-    @yardoc.run
-    @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
-    @yardoc.files.should == ["FILE1", "FILE2"]
-  end
-  
-  it "should setup visibility rules as verifier" do
-    methobj = CodeObjects::MethodObject.new(:root, :test) {|o| o.visibility = :private }
-    File.should_receive(:read_binary).with("test").and_return("--private")
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.options_file = "test"
-    @yardoc.run
-    @yardoc.options[:verifier].call(methobj).should be_true
-  end
+    should_accept('--document') do |arg|
+      @yardoc = CLI::Yardoc.new
+      @yardoc.use_yardopts_file = false
+      @yardoc.should_receive(:support_rdoc_document_file!).and_return([])
+      @yardoc.parse_arguments('--no-document', arg)
+      @yardoc.use_document_file.should == true
+    end
 
-  it "should use String#shell_split to split .yardopts tokens" do
-    optsdata = "foo bar"
-    optsdata.should_receive(:shell_split)
-    File.should_receive(:read_binary).with("test").and_return(optsdata)
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.options_file = "test"
-    @yardoc.run
-  end
-  
-  it "should allow --title to have multiple spaces in .yardopts" do
-    File.should_receive(:read_binary).with("test").and_return("--title \"Foo Bar\"")
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.options_file = "test"
-    @yardoc.run
-    @yardoc.options[:title].should == "Foo Bar"
-  end
-  
-  it "should allow opts specified in command line to override yardopts file" do
-    File.should_receive(:read_binary).with(".yardopts").and_return("-o NOTMYPATH")
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.run("-o", "MYPATH", "FILE")
-    @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
-    @yardoc.files.should == ["FILE"]
-  end
-  
-  it "should load the RDoc .document file if found" do
-    File.should_receive(:read_binary).with(".yardopts").and_return("-o NOTMYPATH")
-    @yardoc.stub!(:support_rdoc_document_file!).and_return(["FILE2", "FILE3"])
-    @yardoc.run("-o", "MYPATH", "FILE1")
-    @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
-    @yardoc.files.should == ["FILE2", "FILE3", "FILE1"]
+    should_accept('--no-document') do |arg|
+      @yardoc = CLI::Yardoc.new
+      @yardoc.use_yardopts_file = false
+      @yardoc.should_not_receive(:support_rdoc_document_file!)
+      @yardoc.parse_arguments('--document', arg)
+      @yardoc.use_document_file.should == false
+    end
+    
+    should_accept('-b', '--db') do |arg|
+      @yardoc.parse_arguments(arg, 'test')
+      Registry.yardoc_file.should == 'test'
+      Registry.yardoc_file = '.yardoc'
+    end
+    
+    should_accept('-n', '--no-output') do |arg|
+      Templates::Engine.should_not_receive(:generate)
+      @yardoc.run(arg)
+    end
+    
+    should_accept('--exclude') do |arg|
+      YARD.should_receive(:parse).with(['a'], ['nota', 'b'])
+      @yardoc.run(arg, 'nota', arg, 'b', 'a')
+    end
+    
+    should_accept('--no-save') do |arg|
+      YARD.should_receive(:parse)
+      Registry.should_not_receive(:save)
+      @yardoc.run(arg)
+    end
   end
   
-  it "should accept extra files if specified after '-' with source files" do
-    File.should_receive(:file?).with('extra_file1').and_return(true)
-    File.should_receive(:file?).with('extra_file2').and_return(true)
-    @yardoc.optparse *%w( file1 file2 - extra_file1 extra_file2 )
-    @yardoc.files.should == %w( file1 file2 )
-    @yardoc.options[:files].should == %w( extra_file1 extra_file2 )
-  end
-  
-  it "should accept files section only containing extra files" do
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.stub!(:yardopts).and_return([])
-    @yardoc.parse_arguments *%w( - LICENSE )
-    @yardoc.files.should == %w( lib/**/*.rb ext/**/*.c )
-    @yardoc.options[:files].should == %w( LICENSE )
-  end
+  describe 'Output options' do
+    it "should accept --title" do
+      @yardoc.parse_arguments('--title', 'hello world')
+      @yardoc.options[:title].should == 'hello world'
+    end
 
-  it "should accept globs as extra files" do
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.stub!(:yardopts).and_return([])
-    Dir.should_receive(:glob).with('README*').and_return []
-    Dir.should_receive(:glob).with('*.txt').and_return ['a.txt', 'b.txt']
-    File.should_receive(:file?).with('a.txt').and_return(true)
-    File.should_receive(:file?).with('b.txt').and_return(true)
-    @yardoc.parse_arguments *%w( file1 file2 - *.txt )
-    @yardoc.files.should == %w( file1 file2 )
-    @yardoc.options[:files].should == %w( a.txt b.txt )
-  end
-  
-  it "should accept no params and parse lib/**/*.rb ext/**/*.c" do
-    @yardoc.stub!(:support_rdoc_document_file!).and_return([])
-    @yardoc.stub!(:yardopts).and_return([])
-    @yardoc.parse_arguments
-    @yardoc.files.should == %w( lib/**/*.rb ext/**/*.c )
-  end
-  
-  it "should accept a --query" do
-    @yardoc.optparse *%w( --query @return )
-    @yardoc.options[:verifier].should be_a(Verifier)
-  end
-  
-  it "should accept multiple --query arguments" do
-    obj = mock(:object)
-    obj.should_receive(:tag).ordered.with('return').and_return(true)
-    obj.should_receive(:tag).ordered.with('tag').and_return(false)
-    @yardoc.optparse *%w( --query @return --query @tag )
-    @yardoc.options[:verifier].should be_a(Verifier)
-    @yardoc.options[:verifier].call(obj).should == false
-  end
-  
-  it "should accept --no-private" do
-    obj = mock(:object)
-    obj.should_receive(:tag).ordered.with(:private).and_return(true)
-    @yardoc.optparse *%w( --no-private )
-    @yardoc.options[:verifier].call(obj).should == false
-  end
-  
-  it "should hide object if namespace is @private with --no-private" do
-    ns = mock(:namespace)
-    ns.stub!(:type).and_return(:module)
-    ns.should_receive(:tag).ordered.with(:private).and_return(true)
-    obj = mock(:object)
-    obj.stub!(:namespace).and_return(ns)
-    obj.should_receive(:tag).ordered.with(:private).and_return(false)
-    @yardoc.optparse *%w( --no-private )
-    @yardoc.options[:verifier].call(obj).should == false
-  end
-  
-  it "should not call #tag on namespace if namespace is proxy with --no-private" do
-    ns = mock(:namespace)
-    ns.stub!(:type).and_return(:proxy)
-    ns.should_not_receive(:tag)
-    obj = mock(:object)
-    obj.stub!(:namespace).and_return(ns)
-    obj.should_receive(:tag).ordered.with(:private).and_return(false)
-    @yardoc.optparse *%w( --no-private )
-    @yardoc.options[:verifier].call(obj).should == true
-  end
-  
-  it "should hide methods inside a 'private' class/module with --no-private" do
-    Registry.clear
-    YARD.parse_string <<-eof
-      # @private
-      class A
-        def foo; end
+    it "should allow --title to have multiple spaces in .yardopts" do
+      File.should_receive(:read_binary).with("test").and_return("--title \"Foo Bar\"")
+      @yardoc.options_file = "test"
+      @yardoc.use_yardopts_file = true
+      @yardoc.run
+      @yardoc.options[:title].should == "Foo Bar"
+    end
+
+    it "should alias --main to the --readme flag" do
+      readme = File.join(File.dirname(__FILE__),'..','..','README.md')
+
+      @yardoc.parse_arguments('--main', readme)
+      @yardoc.options[:readme].should == readme
+    end
+
+    it "should select a markup provider when --markup-provider or -mp is set" do
+      @yardoc.parse_arguments("-M", "test")
+      @yardoc.options[:markup_provider].should == :test
+      @yardoc.parse_arguments("--markup-provider", "test2")
+      @yardoc.options[:markup_provider].should == :test2
+    end
+
+    it "should accept --default-return" do
+      @yardoc.parse_arguments *%w( --default-return XYZ )
+      @yardoc.options[:default_return].should == "XYZ"
+    end
+
+    it "should allow --hide-void-return to be set" do
+      @yardoc.parse_arguments *%w( --hide-void-return )
+      @yardoc.options[:hide_void_return].should be_true
+    end
+
+    it "should generate all objects with --use-cache" do
+      YARD.should_receive(:parse)
+      Registry.should_receive(:load)
+      Registry.should_receive(:load_all)
+      @yardoc.stub!(:generate).and_return(true)
+      @yardoc.run *%w( --use-cache )
+    end
+
+    it "should not print statistics with --no-stats" do
+      @yardoc.stub!(:statistics).and_return(false)
+      CLI::Stats.should_not_receive(:new)
+      @yardoc.run *%w( --no-stats )
+    end
+    
+    describe '--asset' do
+      before do
+        @yardoc.generate = true
+        @yardoc.stub!(:run_generate)
+      end
+      
+      it "should copy assets to output directory" do
+        FileUtils.should_receive(:cp_r).with('a', 'doc/a')
+        @yardoc.run *%w( --asset a )
+        @yardoc.assets.should == {'a' => 'a'}
       end
-    eof
-    @yardoc.optparse *%w( --no-private )
-    @yardoc.options[:verifier].call(Registry.at('A')).should be_false
-    @yardoc.options[:verifier].call(Registry.at('A#foo')).should be_false
+
+      it "should allow multiple --asset options" do
+        FileUtils.should_receive(:cp_r).with('a', 'doc/a')
+        FileUtils.should_receive(:cp_r).with('b', 'doc/b')
+        @yardoc.run *%w( --asset a --asset b )
+        @yardoc.assets.should == {'a' => 'a', 'b' => 'b'}
+      end
+
+      it "should not allow from or to to refer to a path above current path" do
+        log.should_receive(:warn).exactly(4).times.with(/invalid/i)
+        @yardoc.run *%w( --asset ../../../etc/passwd )
+        @yardoc.assets.should be_empty
+        @yardoc.run *%w( --asset a/b/c/d/../../../../../../etc/passwd )
+        @yardoc.assets.should be_empty
+        @yardoc.run *%w( --asset /etc/passwd )
+        @yardoc.assets.should be_empty
+        @yardoc.run *%w( --asset normal:/etc/passwd )
+        @yardoc.assets.should be_empty
+      end
+
+      it "should allow from:to syntax" do
+        FileUtils.should_receive(:cp_r).with('foo', 'doc/bar')
+        @yardoc.run *%w( --asset foo:bar )
+        @yardoc.assets.should == {'foo' => 'bar'}
+      end
+    end
   end
   
-  it "should accept --default-return" do
-    @yardoc.optparse *%w( --default-return XYZ )
-    @yardoc.options[:default_return].should == "XYZ"
+  describe '--no-private option' do
+    it "should accept --no-private" do
+      obj = mock(:object)
+      obj.should_receive(:tag).ordered.with(:private).and_return(true)
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(obj).should == false
+    end
+
+    it "should hide object if namespace is @private with --no-private" do
+      ns = mock(:namespace)
+      ns.stub!(:type).and_return(:module)
+      ns.should_receive(:tag).ordered.with(:private).and_return(true)
+      obj = mock(:object)
+      obj.stub!(:namespace).and_return(ns)
+      obj.should_receive(:tag).ordered.with(:private).and_return(false)
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(obj).should == false
+    end
+
+    it "should not call #tag on namespace if namespace is proxy with --no-private" do
+      ns = mock(:namespace)
+      ns.stub!(:type).and_return(:proxy)
+      ns.should_not_receive(:tag)
+      obj = mock(:object)
+      obj.stub!(:type).and_return(:class)
+      obj.stub!(:namespace).and_return(ns)
+      obj.stub!(:visibility).and_return(:public)
+      obj.should_receive(:tag).ordered.with(:private).and_return(false)
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(obj).should == true
+    end
+
+    it "should hide methods inside a 'private' class/module with --no-private" do
+      Registry.clear
+      YARD.parse_string <<-eof
+        # @private
+        class ABC
+          def foo; end
+        end
+      eof
+      @yardoc.parse_arguments *%w( --no-private )
+      @yardoc.options[:verifier].call(Registry.at('ABC')).should be_false
+      @yardoc.options[:verifier].call(Registry.at('ABC#foo')).should be_false
+    end
   end
   
-  it "should allow --hide-void-return to be set" do
-    @yardoc.optparse *%w( --hide-void-return )
-    @yardoc.options[:hide_void_return].should be_true
+  describe '.yardopts and .document handling' do
+    before do
+      @yardoc.use_yardopts_file = true
+    end
+    
+    it "should search for and use yardopts file specified by #options_file" do
+      File.should_receive(:read_binary).with("test").and_return("-o \n\nMYPATH\nFILE1 FILE2")
+      @yardoc.use_document_file = false
+      @yardoc.options_file = "test"
+      @yardoc.run
+      @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
+      @yardoc.files.should == ["FILE1", "FILE2"]
+    end
+
+    it "should use String#shell_split to split .yardopts tokens" do
+      optsdata = "foo bar"
+      optsdata.should_receive(:shell_split)
+      File.should_receive(:read_binary).with("test").and_return(optsdata)
+      @yardoc.options_file = "test"
+      @yardoc.run
+    end
+
+    it "should allow opts specified in command line to override yardopts file" do
+      File.should_receive(:read_binary).with(".yardopts").and_return("-o NOTMYPATH")
+      @yardoc.run("-o", "MYPATH", "FILE")
+      @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
+      @yardoc.files.should == ["FILE"]
+    end
+
+    it "should load the RDoc .document file if found" do
+      File.should_receive(:read_binary).with(".yardopts").and_return("-o NOTMYPATH")
+      @yardoc.use_document_file = true
+      @yardoc.stub!(:support_rdoc_document_file!).and_return(["FILE2", "FILE3"])
+      @yardoc.run("-o", "MYPATH", "FILE1")
+      @yardoc.options[:serializer].options[:basepath].should == "MYPATH"
+      @yardoc.files.should == ["FILE2", "FILE3", "FILE1"]
+    end
   end
   
-  it "should generate all objects with --use-cache" do
-    YARD.should_receive(:parse)
-    Registry.should_receive(:load)
-    Registry.should_receive(:load_all)
-    @yardoc.stub!(:generate).and_return(true)
-    @yardoc.run *%w( --use-cache )
+  describe 'Query options' do
+    before do
+      Registry.clear
+    end
+    
+    it "should setup visibility rules as verifier" do
+      methobj = CodeObjects::MethodObject.new(:root, :test) {|o| o.visibility = :private }
+      File.should_receive(:read_binary).with("test").and_return("--private")
+      @yardoc.use_yardopts_file = true
+      @yardoc.options_file = "test"
+      @yardoc.run
+      @yardoc.options[:verifier].call(methobj).should be_true
+    end
+
+    it "should accept a --query" do
+      @yardoc.parse_arguments *%w( --query @return )
+      @yardoc.options[:verifier].should be_a(Verifier)
+    end
+
+    it "should accept multiple --query arguments" do
+      obj = mock(:object)
+      obj.should_receive(:tag).ordered.with('return').and_return(true)
+      obj.should_receive(:tag).ordered.with('tag').and_return(false)
+      @yardoc.parse_arguments *%w( --query @return --query @tag )
+      @yardoc.options[:verifier].should be_a(Verifier)
+      @yardoc.options[:verifier].call(obj).should == false
+    end
   end
   
-  it "should only generate changed objects with --incremental" do
-    YARD.should_receive(:parse)
-    Registry.should_receive(:load)
-    Registry.should_not_receive(:load_all)
-    @yardoc.stub!(:generate).and_return(true)
-    @yardoc.should_receive(:generate_with_cache)
-    @yardoc.run *%w( --incremental )
-    @yardoc.incremental.should == true
-    @yardoc.use_cache.should == true
-    @yardoc.generate.should == true
+  describe 'Extra file arguments' do
+    it "should accept extra files if specified after '-' with source files" do
+      File.should_receive(:file?).with('extra_file1').and_return(true)
+      File.should_receive(:file?).with('extra_file2').and_return(true)
+      @yardoc.parse_arguments *%w( file1 file2 - extra_file1 extra_file2 )
+      @yardoc.files.should == %w( file1 file2 )
+      @yardoc.options[:files].should == %w( extra_file1 extra_file2 )
+    end
+
+    it "should accept files section only containing extra files" do
+      @yardoc.parse_arguments *%w( - LICENSE )
+      @yardoc.files.should == %w( lib/**/*.rb ext/**/*.c )
+      @yardoc.options[:files].should == %w( LICENSE )
+    end
+
+    it "should accept globs as extra files" do
+      Dir.should_receive(:glob).with('README*').and_return []
+      Dir.should_receive(:glob).with('*.txt').and_return ['a.txt', 'b.txt']
+      File.should_receive(:file?).with('a.txt').and_return(true)
+      File.should_receive(:file?).with('b.txt').and_return(true)
+      @yardoc.parse_arguments *%w( file1 file2 - *.txt )
+      @yardoc.files.should == %w( file1 file2 )
+      @yardoc.options[:files].should == %w( a.txt b.txt )
+    end
+
+    it "should warn if extra file is not found" do
+      log.should_receive(:warn).with(/Could not find extra file: UNKNOWN/)
+      @yardoc.parse_arguments *%w( - UNKNOWN )
+    end
+
+    it "should warn if readme file is not found" do
+      log.should_receive(:warn).with(/Could not find readme file: UNKNOWN/)
+      @yardoc.parse_arguments *%w( -r UNKNOWN )
+    end
   end
   
-  it "should warn if extra file is not found" do
-    log.should_receive(:warn).with(/Could not find extra file: UNKNOWN/)
-    @yardoc.optparse *%w( - UNKNOWN )
+  describe 'Source file arguments' do
+    it "should accept no params and parse lib/**/*.rb ext/**/*.c" do
+      @yardoc.parse_arguments
+      @yardoc.files.should == %w( lib/**/*.rb ext/**/*.c )
+    end
   end
   
-  it "should warn if readme file is not found" do
-    log.should_receive(:warn).with(/Could not find readme file: UNKNOWN/)
-    @yardoc.optparse *%w( -r UNKNOWN )
+  describe 'Tags options' do
+    def tag_created(switch, factory_method)
+      visible_tags = mock(:visible_tags)
+      visible_tags.should_receive(:|).ordered.with([:foo])
+      visible_tags.should_receive(:-).ordered.with([]).and_return(visible_tags)
+      Tags::Library.should_receive(:define_tag).with(nil, :foo, factory_method)
+      Tags::Library.stub!(:visible_tags=)
+      Tags::Library.should_receive(:visible_tags).at_least(1).times.and_return(visible_tags)
+      @yardoc.parse_arguments("--#{switch}-tag", 'foo')
+    end
+    
+    def tag_hidden(tag)
+      visible_tags = mock(:visible_tags)
+      visible_tags.should_receive(:|).ordered.with([tag])
+      visible_tags.should_receive(:-).ordered.with([tag]).and_return([])
+      Tags::Library.should_receive(:define_tag).with(nil, tag, nil)
+      Tags::Library.stub!(:visible_tags=)
+      Tags::Library.should_receive(:visible_tags).at_least(1).times.and_return(visible_tags)
+    end
+
+    it "should accept --tag" do
+      Tags::Library.should_receive(:define_tag).with('Title of Foo', :foo, nil)
+      @yardoc.parse_arguments('--tag', 'foo:Title of Foo')
+    end
+
+    it "should accept --tag without title" do
+      Tags::Library.should_receive(:define_tag).with(nil, :foo, nil)
+      @yardoc.parse_arguments('--tag', 'foo')
+    end
+    
+    it "should only list tag once if declared twice" do
+      visible_tags = []
+      Tags::Library.stub!(:define_tag)
+      Tags::Library.stub!(:visible_tags).and_return([:foo])
+      Tags::Library.stub!(:visible_tags=).with {|value| visible_tags = value }
+      @yardoc.parse_arguments('--tag', 'foo', '--tag', 'foo')
+      visible_tags.should == [:foo]
+    end
+
+    it "should accept --type-tag" do
+      tag_created 'type', :with_types
+    end
+
+    it "should accept --type-name-tag" do
+      tag_created 'type-name', :with_types_and_name
+    end
+
+    it "should accept --name-tag" do
+      tag_created 'name', :with_name
+    end
+
+    it "should accept --title-tag" do
+      tag_created 'title', :with_title_and_text
+    end
+    
+    it "should accept --hide-tag before tag is listed" do
+      tag_hidden(:anewfoo)
+      @yardoc.parse_arguments('--hide-tag', 'anewfoo', '--tag', 'anewfoo')
+    end
+    
+    it "should accept --hide-tag after tag is listed" do
+      tag_hidden(:anewfoo2)
+      @yardoc.parse_arguments('--tag', 'anewfoo2', '--hide-tag', 'anewfoo2')
+    end
+    
+    it "should accept --transitive-tag" do
+      @yardoc.parse_arguments('--transitive-tag', 'foo')
+      Tags::Library.transitive_tags.should include(:foo)
+    end
   end
 end