yard 0.8.2.1 → 0.8.3

data/lib/yard/tags/directives.rb

@@ -205,7 +205,7 @@ module YARD
     #
     # === Escaping Interpolation
     #
-    # Interpolation can be escaped by prefixing the +$+ with +\+, like so:
+    # Interpolation can be escaped by prefixing the +$+ with +\\\+, like so:
     #
     #     # @!macro foo
     #     #   I have \$2.00 USD.

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

@@ -60,7 +60,8 @@ module YARD
         if provider.to_s == 'RDiscount'
           provider.new(text, :autolink).to_html
         elsif provider.to_s == 'RedcarpetCompat'
-          provider.new(text, :gh_blockcode, :fenced_code, :autolink).to_html
+          provider.new(text, :no_intraemphasis, :gh_blockcode,
+                             :fenced_code, :autolink).to_html
         else
           provider.new(text).to_html
         end
@@ -508,11 +509,12 @@ module YARD
       # @return [String] the current character set
       # @since 0.5.4
       def charset
-        if @file && RUBY19
+        has_encoding = defined?(::Encoding)
+        if @file && has_encoding
           lang = @file.contents.encoding.to_s
         else
-          return 'utf-8' unless RUBY19 || lang = ENV['LANG']
-          if RUBY19
+          return 'utf-8' unless has_encoding || lang = ENV['LANG']
+          if has_encoding
             lang = ::Encoding.default_external.name.downcase
           else
             lang = lang.downcase.split('.').last

data/lib/yard/templates/template.rb

@@ -58,13 +58,25 @@ module YARD
       module ClassMethods
         attr_accessor :path, :full_path
 
+        # @return [Array<String>] a list of full paths
+        # @note This method caches path results. Paths should not be modified
+        #   after this method is called; call {#reset_full_paths} to reset cache.
         def full_paths
-          included_modules.inject([full_path]) do |paths, mod|
+          reset_full_paths unless defined? @cached_included_modules
+          return @full_paths if included_modules == @cached_included_modules
+
+          @cached_included_modules = included_modules
+          @full_paths = included_modules.inject([full_path]) do |paths, mod|
             paths |= mod.full_paths if mod.respond_to?(:full_paths)
             paths
           end
         end
 
+        # Resets cache for {#full_paths}
+        def reset_full_paths
+          @cached_included_modules = nil
+        end
+
         def initialize(path, full_paths)
           full_path = full_paths.shift
           self.path = path

data/lib/yard/version.rb

@@ -0,0 +1,3 @@
+module YARD
+  VERSION = "0.8.3"
+end

data/spec/cli/config_spec.rb

@@ -17,7 +17,7 @@ describe YARD::CLI::Config do
     it "should accept --list" do
       opts = YARD::Config.options
       YAML.should_receive(:dump).twice.and_return("--- foo\nbar\nbaz")
-      @config.should_receive(:puts).twice.with("bar\nbaz")
+      log.should_receive(:puts).twice.with("bar\nbaz")
       run
       run('--list')
       YARD::Config.options.should == opts
@@ -27,7 +27,7 @@ describe YARD::CLI::Config do
   describe 'Viewing an item' do
     it "should view item if no value is given" do
       YARD::Config.options[:foo] = 'bar'
-      @config.should_receive(:puts).with('"bar"')
+      log.should_receive(:puts).with('"bar"')
       run 'foo'
       YARD::Config.options[:foo].should == 'bar'
     end

data/spec/cli/diff_spec.rb

@@ -12,7 +12,7 @@ describe YARD::CLI::Diff do
   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/)
+      log.should_receive(:puts).with(/Usage/)
       @diff.run
     end
   end
@@ -29,13 +29,37 @@ describe YARD::CLI::Diff do
       @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 )
       @objects = [@objects1, @objects2]
-      @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).twice.and_return do
-        @objects[@all_call += 1].map {|o| P(o) }
+      @diff.should_receive(:load_gem_data).ordered.with('gem1') do
+        Registry.clear
+        YARD.parse_string <<-eof
+          class C
+            def fooey; end
+            def baz; FOO end
+          end
+          class D
+            def self.bar; end
+          end
+        eof
       end
-      @diff.stub!(:print) {|data| @data << data }
-      @diff.stub!(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
+      @diff.should_receive(:load_gem_data).ordered.with('gem2') do
+        Registry.clear
+        YARD.parse_string <<-eof
+          module A
+            module B
+              class C; end
+            end
+            def self.foo; end
+            def foo; end
+          end
+          class C
+            def self.foo; end
+            def self.bar; end
+            def baz; BAR end
+          end
+        eof
+      end
+      log.stub!(:print) {|data| @data << data }
+      log.stub!(:puts) {|*args| @data << args.join("\n"); @data << "\n" }
       @diff.run(*(args + ['gem1', 'gem2']))
     end
 
@@ -44,16 +68,33 @@ describe YARD::CLI::Diff do
       @data.string.should == <<-eof
 Added objects:
 
-  A (...)
-  B
-  C.bar
-  C.foo
+  A ((stdin):1) (...)
+  A::B::C ((stdin):3)
+  C.bar ((stdin):10)
+  C.foo ((stdin):9)
+
+Modified objects:
+
+  C#baz ((stdin):3)
 
 Removed objects:
 
-  C#fooey
-  D.bar
+  C#fooey ((stdin):2)
+  D ((stdin):5) (...)
 
+eof
+    end
+
+    it "should accept --compact" do
+      run('--compact')
+      @data.string.should == <<-eof
+A A ((stdin):1) (...)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D ((stdin):5) (...)
 eof
     end
 
@@ -63,23 +104,69 @@ eof
         @data.string.should == <<-eof
 Added objects:
 
-  A
-  A#foo
-  A.foo
-  A::B
-  A::B::C
-  B
-  C.bar
-  C.foo
+  A ((stdin):1)
+  A#foo ((stdin):6)
+  A.foo ((stdin):5)
+  A::B ((stdin):2)
+  A::B::C ((stdin):3)
+  C.bar ((stdin):10)
+  C.foo ((stdin):9)
+
+Modified objects:
+
+  C#baz ((stdin):3)
 
 Removed objects:
 
-  C#fooey
-  D.bar
+  C#fooey ((stdin):2)
+  D ((stdin):5)
+  D.bar ((stdin):6)
 
 eof
       end
     end
+
+    it "should accept --compact and --all" do
+      run('--compact', '--all')
+      @data.string.should == <<-eof
+A A ((stdin):1)
+A A#foo ((stdin):6)
+A A.foo ((stdin):5)
+A A::B ((stdin):2)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D ((stdin):5)
+D D.bar ((stdin):6)
+eof
+    end
+
+    it "should accept --no-modified" do
+      run('--compact', '--no-modified')
+      @data.string.should == <<-eof
+A A ((stdin):1) (...)
+A A::B::C ((stdin):3)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+D C#fooey ((stdin):2)
+D D ((stdin):5) (...)
+eof
+    end
+
+    it "should accept --query" do
+      run('--compact', '--query', 'o.type == :method')
+      @data.string.should == <<-eof
+A A#foo ((stdin):6)
+A A.foo ((stdin):5)
+A C.bar ((stdin):10)
+A C.foo ((stdin):9)
+M C#baz ((stdin):3)
+D C#fooey ((stdin):2)
+D D.bar ((stdin):6)
+eof
+    end
   end
 
   describe 'File searching' do

data/spec/cli/graph_spec.rb

@@ -1,10 +1,17 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-describe YARD::CLI::Yardoc do
+describe YARD::CLI::Graph do
   it "should serialize output" do
-    Registry.should_receive(:load)
-    @graph = YARD::CLI::Graph.new
-    @graph.options.serializer.should_receive(:serialize).once
-    @graph.run
+    Registry.should_receive(:load).at_least(1).times
+    subject.stub(:yardopts) { [] }
+    subject.options.serializer.should_receive(:serialize).once
+    subject.run
+  end
+
+  it 'should read yardoc file from .yardopts' do
+    subject.stub(:yardopts) { %w(--db /path/to/db) }
+    subject.options.serializer.should_receive(:serialize).once
+    subject.run
+    Registry.yardoc_file.should == '/path/to/db'
   end
 end

data/spec/cli/help_spec.rb

@@ -15,7 +15,7 @@ describe YARD::CLI::Help do
     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/)
+      log.should_receive(:puts).with(/not found/)
       help.run('unknown')
     end
   end

data/spec/cli/server_spec.rb

@@ -4,14 +4,24 @@ class Server::WebrickAdapter; def start; end end
 
 describe YARD::CLI::Server do
   before do
+    CLI::Yardoc.stub!(:run)
     @no_verify_libraries = false
+    @set_libraries = true
     @no_adapter_mock = false
     @libraries = {}
     @options = {:single_library => true, :caching => false}
     @server_options = {:Port => 8808}
     @adapter = mock(:adapter)
     @adapter.stub!(:setup)
-    @cli = YARD::CLI::Server.new
+    new_cli
+  end
+
+  after(:all) do
+    Server::Adapter.shutdown
+  end
+
+  def new_cli
+    @cli = subject
   end
 
   def rack_required
@@ -27,193 +37,273 @@ describe YARD::CLI::Server do
   end
 
   def run(*args)
-    if @libraries.empty?
-      library = Server::LibraryVersion.new(File.basename(Dir.pwd), nil, File.expand_path('.yardoc'))
+    if @set_libraries && @libraries.empty?
+      library = Server::LibraryVersion.new(
+        File.basename(Dir.pwd), nil, File.expand_path('.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(File.expand_path(lib.yardoc_file)).and_return(true) } }
+      @libraries.values.each do |libs|
+        libs.each do |lib|
+          yfile = File.expand_path(lib.yardoc_file)
+          File.stub!(:exist?).with(yfile).and_return(true)
+        end
+      end
     end
     unless @no_adapter_mock
       @cli.stub!(:adapter).and_return(@adapter)
-      @adapter.should_receive(:new).with(@libraries, @options, @server_options).and_return(@adapter)
+      @adapter.should_receive(:new).
+        with(@libraries, @options, @server_options).and_return(@adapter)
       @adapter.should_receive(:start)
     end
+
     @cli.run(*args.flatten)
-    @cli = YARD::CLI::Server.new
-  end
+    assert_libraries @libraries, @cli.libraries
 
-  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, File.expand_path('.yardoc'))]
-    run
+    new_cli
   end
 
-  it "should use .yardoc as yardoc file is library list is odd" do
-    @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('.yardoc'))]
-    run 'a'
+  def assert_libraries(expected_libs, actual_libs)
+    actual_libs.should == expected_libs
+    expected_libs.each do |name, libs|
+      libs.each_with_index do |expected,i|
+        actual = actual_libs[name][i]
+        [:source, :source_path, :yardoc_file].each do |m|
+          actual.send(m).should == expected.send(m)
+        end
+      end
+    end
   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, File.expand_path('b'))]
-    @libraries['c'] = [Server::LibraryVersion.new('c', nil, File.expand_path('.yardoc'))]
-    run %w(a b c)
+  # Mocks the existence of a file.
+  def mock_file(filename, content = nil)
+    File.stub!(:exist?).with(filename).and_return(true)
+    File.stub!(:read_binary).with(filename).and_return(content) if content
+    filename_e = File.expand_path(filename)
+    mock_file(filename_e) unless filename_e == filename
   end
 
-  it "should accept -m, --multi-library" do
-    @options[:single_library] = false
-    run '-m'
-    run '--multi-library'
-  end
+  describe 'when .yardopts file exists' do
+    before :each do
+      Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
+      Dir.stub!(:pwd).and_return('/path/to/bar')
+      @name = 'bar'
+    end
 
-  it "should accept -c, --cache" do
-    @options[:caching] = true
-    run '-c'
-    run '--cache'
-  end
+    it "should use .yardoc as the yardoc db if .yardopts doesn't specify an alternate path" do
+      mock_file '/path/to/bar/.yardopts', '--protected'
+      @libraries[@name] = [Server::LibraryVersion.new(@name, nil, '/path/to/bar/.yardoc')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run
+    end
 
-  it "should accept -r, --reload" do
-    @options[:incremental] = true
-    run '-r'
-    run '--reload'
-  end
+    it "should use the yardoc db location specified by .yardopts" do
+      mock_file '/path/to/bar/.yardopts', '--db foo'
+      @libraries[@name] = [Server::LibraryVersion.new(@name, nil, '/path/to/bar/foo')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run
+    end
 
-  it "should accept -d, --daemon" do
-    @server_options[:daemonize] = true
-    run '-d'
-    run '--daemon'
+    it "should parse .yardopts when the library list is odd" do
+      mock_file '/path/to/bar/.yardopts', '--db foo'
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, '/path/to/bar/foo')]
+      @libraries.values[0][0].source_path = '/path/to/bar'
+      run 'a'
+    end
   end
 
-  it "should accept -p, --port" do
-    @server_options[:Port] = 10
-    run '-p', '10'
-    run '--port', '10'
-  end
+  describe "when .yardopts file doesn't exist" do
+    before :each do
+      File.stub(:exist?).with(/^(.*[\\\/])?\.yardopts$/).and_return(false)
+    end
 
-  it "should accept --docroot" do
-    @server_options[:DocumentRoot] = Dir.pwd + '/__foo/bar'
-    run '--docroot', '__foo/bar'
-  end
+    it "should default to .yardoc if no library is specified" do
+      Dir.should_receive(:pwd).at_least(:once).and_return('/path/to/foo')
+      @libraries['foo'] = [Server::LibraryVersion.new('foo', nil, '/path/to/foo/.yardoc')]
+      run
+    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 use .yardoc as yardoc file if library list is odd" do
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('.yardoc'))]
+      run 'a'
+    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 force multi library if more than one library is listed" do
+      File.stub(:exist?).with('b').and_return(true)
+      @options[:single_library] = false
+      @libraries['a'] = [Server::LibraryVersion.new('a', nil, File.expand_path('b'))]
+      @libraries['c'] = [Server::LibraryVersion.new('c', nil, File.expand_path('.yardoc'))]
+      run %w(a b c)
+    end
 
-  it "should default to Rack adapter if exists on system" do
-    rack_required
-    @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)
+    it "should fail if specified directory does not exist" do
+      @set_libraries = false
+      File.stub(:exist?).with('b').and_return(false)
+      log.should_receive(:warn).with(/Cannot find yardoc db for a: "b"/)
+      run %w(a b)
+    end
   end
 
-  it "should fall back to WEBrick adapter if Rack is not on system" do
-    @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
+  describe 'General options' do
+    before do
+      File.stub(:exist?).with(/\.yardopts$/).and_return(false)
+    end
 
-  it "should accept -s, --server" do
-    @server_options[:server] = 'thin'
-    run '-s', 'thin'
-    run '--server', 'thin'
-  end
+    it "should accept -m, --multi-library" do
+      @options[:single_library] = false
+      run '-m'
+      run '--multi-library'
+    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
+    it "should accept -c, --cache" do
+      @options[:caching] = true
+      run '-c'
+      run '--cache'
+    end
 
-  it "should accept -G, --gemfile" do
-    bundler_required
-    @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}
-    lockfile_parser = mock(:new)
-    lockfile_parser.stub!(:specs).and_return([gem1, gem2])
-    Bundler::LockfileParser.stub!(:new).and_return(lockfile_parser)
-
-    File.should_receive(:exists?).at_least(2).times.with("Gemfile.lock").and_return(true)
-    File.stub!(:read)
-
-    run '-G'
-    run '--gemfile'
-
-    File.should_receive(:exists?).with("different_name.lock").and_return(true)
-    run '--gemfile', 'different_name'
-  end
+    it "should accept -r, --reload" do
+      @options[:incremental] = true
+      run '-r'
+      run '--reload'
+    end
 
-  it "should warn if lockfile is not found (with -G)" do
-    bundler_required
-    File.should_receive(:exists?).with('somefile.lock').and_return(false)
-    log.should_receive(:warn).with(/Cannot find somefile.lock/)
-    run '-G', 'somefile'
-  end
+    it "should accept -d, --daemon" do
+      @server_options[:daemonize] = true
+      run '-d'
+      run '--daemon'
+    end
 
-  it "should error if Bundler not available (with -G)" do
-    @cli.should_receive(:require).with('bundler').and_raise(LoadError)
-    log.should_receive(:error).with(/Bundler not available/)
-    run '-G'
-  end
+    it "should accept -p, --port" do
+      @server_options[:Port] = 10
+      run '-p', '10'
+      run '--port', '10'
+    end
 
-  it "should load template paths after adapter template paths" do
-    unstub_adapter
-    @cli.adapter = Server::WebrickAdapter
-    run '-t', 'foo'
-    Templates::Engine.template_paths.last.should == 'foo'
-  end
+    it "should accept --docroot" do
+      @server_options[:DocumentRoot] = Dir.pwd + '/__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.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.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
+
+    it "should accept -G, --gemfile" do
+      bundler_required
+      @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}
+      lockfile_parser = mock(:new)
+      lockfile_parser.stub!(:specs).and_return([gem1, gem2])
+      Bundler::LockfileParser.stub!(:new).and_return(lockfile_parser)
+
+      File.should_receive(:exist?).at_least(2).times.with("Gemfile.lock").and_return(true)
+      File.stub!(:read)
+
+      run '-G'
+      run '--gemfile'
+
+      File.should_receive(:exist?).with("different_name.lock").and_return(true)
+      run '--gemfile', 'different_name'
+    end
+
+    it "should warn if lockfile is not found (with -G)" do
+      bundler_required
+      File.should_receive(:exist?).with(/\.yardopts$/).at_least(:once).and_return(false)
+      File.should_receive(:exist?).with('somefile.lock').and_return(false)
+      log.should_receive(:warn).with(/Cannot find somefile.lock/)
+      run '-G', 'somefile'
+    end
+
+    it "should error if Bundler not available (with -G)" do
+      @cli.should_receive(:require).with('bundler').and_raise(LoadError)
+      log.should_receive(:error).with(/Bundler not available/)
+      run '-G'
+    end
+
+    it "should load template paths after adapter template paths" do
+      unstub_adapter
+      @cli.adapter = Server::WebrickAdapter
+      run '-t', 'foo'
+      Templates::Engine.template_paths.last.should == 'foo'
+    end
 
-  it "should load ruby code (-e) after adapter" do
-    unstub_adapter
-    @cli.adapter = Server::WebrickAdapter
-    path = File.dirname(__FILE__) + '/tmp.adapterscript.rb'
-    begin
-      File.open(path, 'w') do |f|
-        f.puts "YARD::Templates::Engine.register_template_path 'foo'"
-        f.flush
-        run '-e', f.path
-        Templates::Engine.template_paths.last.should == 'foo'
+    it "should load ruby code (-e) after adapter" do
+      unstub_adapter
+      @cli.adapter = Server::WebrickAdapter
+      path = File.dirname(__FILE__) + '/tmp.adapterscript.rb'
+      begin
+        File.open(path, 'w') do |f|
+          f.puts "YARD::Templates::Engine.register_template_path 'foo'"
+          f.flush
+          run '-e', f.path
+          Templates::Engine.template_paths.last.should == 'foo'
+        end
+      ensure
+        File.unlink(path)
       end
-    ensure
-      File.unlink(path)
     end
   end
 end