yard 0.9.18 → 0.9.23

data/spec/code_objects/proxy_spec.rb

@@ -1,141 +1,147 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::Proxy do
-  before { Registry.clear }
-
-  it "returns the object if it's in the Registry" do
-    ModuleObject.new(:root, :YARD)
-    proxyobj = P(:root, :YARD)
-    expect(proxyobj.type).to eq :module
-    expect(Proxy === proxyobj).to be false
-  end
-
-  it "handles complex string namespaces" do
-    ModuleObject.new(:root, :A)
-    ModuleObject.new(P(nil, :A), :B)
-    expect(P(:root, "A::B")).to be_instance_of(ModuleObject)
-  end
-
-  it "does not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
-    expect(Proxy === P(:root, 'a')).to be true
-    expect(Proxy === P(:root)).to be false
-    MethodObject.new(:root, 'a')
-    expect(Proxy === P(:root, 'a')).to be false
-    x = Proxy.new(:root, 'a')
-    expect(Proxy === x).to be false
-  end
-
-  it "returns the object if it's an included Module" do
-    yardobj = ModuleObject.new(:root, :YARD)
-    pathobj = ClassObject.new(:root, :TestClass)
-    pathobj.instance_mixins << yardobj
-    expect(P(P(nil, :TestClass), :YARD)).to be_instance_of(ModuleObject)
-  end
-
-  it "responds to respond_to?" do
-    ClassObject.new(:root, :Object)
-    ModuleObject.new(:root, :YARD)
-    expect(P(:YARD).respond_to?(:children)).to be true
-    expect(P(:NOTYARD).respond_to?(:children)).to be false
-
-    expect(P(:YARD).respond_to?(:initialize)).to be false
-    expect(P(:YARD).respond_to?(:initialize, true)).to be true
-    expect(P(:NOTYARD).respond_to?(:initialize)).to be false
-    expect(P(:NOTYARD).respond_to?(:initialize, true)).to be true
-  end
-
-  it "makes itself obvious that it's a proxy" do
-    pathobj = P(:root, :YARD)
-    expect(pathobj.class).to eq Proxy
-    expect(Proxy === pathobj).to be true
-  end
-
-  it "pretends it's the object's type if it can resolve" do
-    ModuleObject.new(:root, :YARD)
-    proxyobj = P(:root, :YARD)
-    expect(proxyobj).to be_instance_of(ModuleObject)
-  end
-
-  it "handles instance method names" do
-    obj = P(nil, '#test')
-    expect(obj.name).to eq :test
-    expect(obj.path).to eq "#test"
-    expect(obj.namespace).to eq Registry.root
-  end
-
-  it "handles instance method names under a namespace" do
-    pathobj = ModuleObject.new(:root, :YARD)
-    obj = P(pathobj, "A::B#test")
-    expect(obj.name).to eq :test
-    expect(obj.path).to eq "A::B#test"
-  end
-
-  it "allows type to be changed" do
-    obj = P("InvalidClass")
-    expect(obj.type).to eq :proxy
-    expect(Proxy === obj).to be true
-    obj.type = :class
-    expect(obj.type).to eq :class
-  end
-
-  it "does NOT retain a type change between Proxy objects" do
-    P("InvalidClass").type = :class
-    expect(P("InvalidClass").type).to eq :proxy
-  end
-
-  it "uses type to ensure resolved object is of intended type" do
-    YARD.parse_string <<-eof
-      module Foo
-        class Bar; end
-        def self.Bar; end
-      end
-    eof
-    proxy = Proxy.new(P('Foo'), 'Bar')
-    proxy.type = :method
-    expect(proxy.path).to eq 'Foo.Bar'
-  end
-
-  it "allows type in initializer" do
-    expect(Proxy.new(Registry.root, 'Foo', :method).type).to eq :method
-    expect(P(Registry.root, 'Foo', :method).type).to eq :method
-  end
-
-  it "never equals Registry.root" do
-    expect(P("MYPROXY")).not_to eq Registry.root
-    expect(P("X::A")).not_to eq Registry.root
-  end
-
-  it "resets namespace and name when object is resolved" do
-    obj1 = ModuleObject.new(:root, :YARD)
-    obj2 = ModuleObject.new(:root, :NOTYARD)
-    resolved = Proxy.new(obj2, :YARD)
-    expect(resolved).to eq obj1
-    expect(resolved.namespace).to eq Registry.root
-    expect(resolved.name).to eq :YARD
-  end
-
-  it "ensures that the correct object was resolved" do
-    foo = ModuleObject.new(:root, :Foo)
-    foobar = ModuleObject.new(foo, :Bar)
-    ClassObject.new(foo, :Baz)
-
-    # Remember, we're looking for Qux::Bar, not just 'Bar'
-    proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
-    expect(proxy.type).to eq :proxy
-
-    qux = ModuleObject.new(foo, :Qux)
-    ModuleObject.new(qux, :Bar)
-
-    # Now it should resolve
-    expect(proxy.type).to eq :module
-  end
-
-  it "handles constant names in namespaces" do
-    YARD.parse_string <<-eof
-      module A; end; B = A
-      module B::C; def foo; end end
-    eof
-    expect(Proxy.new(:root, 'B::C')).to eq Registry.at('A::C')
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe YARD::CodeObjects::Proxy do
+  before { Registry.clear }
+
+  it "does not allow constants to be used as a namespace if they do not resolve to a valid namespace" do
+    a = ConstantObject.new(:root, :A)
+    a.value = "$$INVALID$$"
+    expect { P("A::MyClass") }.to raise_error(Parser::UndocumentableError)
+  end
+
+  it "returns the object if it's in the Registry" do
+    ModuleObject.new(:root, :YARD)
+    proxyobj = P(:root, :YARD)
+    expect(proxyobj.type).to eq :module
+    expect(Proxy === proxyobj).to be false
+  end
+
+  it "handles complex string namespaces" do
+    ModuleObject.new(:root, :A)
+    ModuleObject.new(P(nil, :A), :B)
+    expect(P(:root, "A::B")).to be_instance_of(ModuleObject)
+  end
+
+  it "does not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
+    expect(Proxy === P(:root, 'a')).to be true
+    expect(Proxy === P(:root)).to be false
+    MethodObject.new(:root, 'a')
+    expect(Proxy === P(:root, 'a')).to be false
+    x = Proxy.new(:root, 'a')
+    expect(Proxy === x).to be false
+  end
+
+  it "returns the object if it's an included Module" do
+    yardobj = ModuleObject.new(:root, :YARD)
+    pathobj = ClassObject.new(:root, :TestClass)
+    pathobj.instance_mixins << yardobj
+    expect(P(P(nil, :TestClass), :YARD)).to be_instance_of(ModuleObject)
+  end
+
+  it "responds to respond_to?" do
+    ClassObject.new(:root, :Object)
+    ModuleObject.new(:root, :YARD)
+    expect(P(:YARD).respond_to?(:children)).to be true
+    expect(P(:NOTYARD).respond_to?(:children)).to be false
+
+    expect(P(:YARD).respond_to?(:initialize)).to be false
+    expect(P(:YARD).respond_to?(:initialize, true)).to be true
+    expect(P(:NOTYARD).respond_to?(:initialize)).to be false
+    expect(P(:NOTYARD).respond_to?(:initialize, true)).to be true
+  end
+
+  it "makes itself obvious that it's a proxy" do
+    pathobj = P(:root, :YARD)
+    expect(pathobj.class).to eq Proxy
+    expect(Proxy === pathobj).to be true
+  end
+
+  it "pretends it's the object's type if it can resolve" do
+    ModuleObject.new(:root, :YARD)
+    proxyobj = P(:root, :YARD)
+    expect(proxyobj).to be_instance_of(ModuleObject)
+  end
+
+  it "handles instance method names" do
+    obj = P(nil, '#test')
+    expect(obj.name).to eq :test
+    expect(obj.path).to eq "#test"
+    expect(obj.namespace).to eq Registry.root
+  end
+
+  it "handles instance method names under a namespace" do
+    pathobj = ModuleObject.new(:root, :YARD)
+    obj = P(pathobj, "A::B#test")
+    expect(obj.name).to eq :test
+    expect(obj.path).to eq "A::B#test"
+  end
+
+  it "allows type to be changed" do
+    obj = P("InvalidClass")
+    expect(obj.type).to eq :proxy
+    expect(Proxy === obj).to be true
+    obj.type = :class
+    expect(obj.type).to eq :class
+  end
+
+  it "does NOT retain a type change between Proxy objects" do
+    P("InvalidClass").type = :class
+    expect(P("InvalidClass").type).to eq :proxy
+  end
+
+  it "uses type to ensure resolved object is of intended type" do
+    YARD.parse_string <<-eof
+      module Foo
+        class Bar; end
+        def self.Bar; end
+      end
+    eof
+    proxy = Proxy.new(P('Foo'), 'Bar')
+    proxy.type = :method
+    expect(proxy.path).to eq 'Foo.Bar'
+  end
+
+  it "allows type in initializer" do
+    expect(Proxy.new(Registry.root, 'Foo', :method).type).to eq :method
+    expect(P(Registry.root, 'Foo', :method).type).to eq :method
+  end
+
+  it "never equals Registry.root" do
+    expect(P("MYPROXY")).not_to eq Registry.root
+    expect(P("X::A")).not_to eq Registry.root
+  end
+
+  it "resets namespace and name when object is resolved" do
+    obj1 = ModuleObject.new(:root, :YARD)
+    obj2 = ModuleObject.new(:root, :NOTYARD)
+    resolved = Proxy.new(obj2, :YARD)
+    expect(resolved).to eq obj1
+    expect(resolved.namespace).to eq Registry.root
+    expect(resolved.name).to eq :YARD
+  end
+
+  it "ensures that the correct object was resolved" do
+    foo = ModuleObject.new(:root, :Foo)
+    foobar = ModuleObject.new(foo, :Bar)
+    ClassObject.new(foo, :Baz)
+
+    # Remember, we're looking for Qux::Bar, not just 'Bar'
+    proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
+    expect(proxy.type).to eq :proxy
+
+    qux = ModuleObject.new(foo, :Qux)
+    ModuleObject.new(qux, :Bar)
+
+    # Now it should resolve
+    expect(proxy.type).to eq :module
+  end
+
+  it "handles constant names in namespaces" do
+    YARD.parse_string <<-eof
+      module A; end; B = A
+      module B::C; def foo; end end
+    eof
+    expect(Proxy.new(:root, 'B::C')).to eq Registry.at('A::C')
+  end
+end

data/spec/code_objects/spec_helper.rb

@@ -1,3 +1,3 @@
-# frozen_string_literal: true
-
-include CodeObjects
+# frozen_string_literal: true
+
+include CodeObjects

data/spec/config_spec.rb

@@ -1,171 +1,171 @@
-# frozen_string_literal: true
-require 'yaml'
-
-RSpec.describe YARD::Config do
-  describe ".load" do
-    before do
-      expect(File).to receive(:file?).twice.with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
-    end
-
-    it "uses default options if no ~/.yard/config is found" do
-      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      YARD::Config.load
-      expect(YARD::Config.options).to eq YARD::Config::DEFAULT_CONFIG_OPTIONS
-    end
-
-    it "overwrites options with data in ~/.yard/config" do
-      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
-      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      expect(YAML).to receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return('test' => true)
-      YARD::Config.load
-      expect(YARD::Config.options[:test]).to be true
-    end
-
-    it "ignores any plugins specified in '~/.yard/ignored_plugins'" do
-      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
-      expect(File).to receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
-      YARD::Config.load
-      expect(YARD::Config.options[:ignored_plugins]).to eq ['yard-plugin', 'yard-plugin2']
-      expect(YARD::Config).not_to receive(:require).with('yard-plugin2')
-      expect(YARD::Config.load_plugin('yard-plugin2')).to be false
-    end
-
-    it "loads safe_mode setting from --safe command line option" do
-      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      ARGV.replace(['--safe'])
-      YARD::Config.load
-      expect(YARD::Config.options[:safe_mode]).to be true
-      ARGV.replace([''])
-    end
-  end
-
-  describe ".save" do
-    it "saves options to config file" do
-      allow(YARD::Config).to receive(:options).and_return(:a => 1, :b => %w(a b c))
-      file = double(:file)
-      expect(File).to receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
-      expect(file).to receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
-      YARD::Config.save
-    end
-  end
-
-  describe ".load_plugin" do
-    it "loads a plugin by 'name' as 'yard-name'" do
-      expect(YARD::Config).to receive(:require).with('yard-foo')
-      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
-      expect(YARD::Config.load_plugin('foo')).to be true
-    end
-
-    it "does not load plugins like 'doc-*'" do
-      expect(YARD::Config).not_to receive(:require).with('yard-doc-core')
-      YARD::Config.load_plugin('doc-core')
-      YARD::Config.load_plugin('yard-doc-core')
-    end
-
-    it "loads plugin by 'yard-name' as 'yard-name'" do
-      expect(YARD::Config).to receive(:require).with('yard-foo')
-      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
-      expect(YARD::Config.load_plugin('yard-foo')).to be true
-    end
-
-    it "loads plugin by 'yard_name' as 'yard_name'" do
-      expect(YARD::Config).to receive(:require).with('yard_foo')
-      expect(log).to receive(:debug).with(/Loading plugin 'yard_foo'/).once
-      log.show_backtraces = false
-      expect(YARD::Config.load_plugin('yard_foo')).to be true
-    end
-
-    it "logs error if plugin is not found" do
-      expect(YARD::Config).to receive(:require).with('yard-foo').and_raise(LoadError)
-      expect(log).to receive(:error).with(/Error loading plugin 'yard-foo'/).once
-      expect(YARD::Config.load_plugin('yard-foo')).to be false
-    end
-
-    it "sanitizes plugin name (remove /'s)" do
-      expect(YARD::Config).to receive(:require).with('yard-foofoo')
-      expect(YARD::Config.load_plugin('foo/foo')).to be true
-    end
-
-    it "ignores plugins in :ignore_plugins" do
-      allow(YARD::Config).to receive(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
-      expect(YARD::Config.load_plugin('foo')).to be false
-      expect(YARD::Config.load_plugin('bar')).to be false
-    end
-  end
-
-  describe ".load_plugins" do
-    it "loads gem plugins if :load_plugins is true" do
-      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
-      allow(YARD::Config).to receive(:load_plugin)
-      expect(YARD::Config).to receive(:require).with('rubygems')
-      YARD::Config.load_plugins
-    end
-
-    it "ignores gem loading if RubyGems cannot load" do
-      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
-      expect(YARD::Config).to receive(:require).with('rubygems').and_raise(LoadError)
-      expect(YARD::Config.load_plugins).to be false
-    end
-
-    it "loads certain plugins automatically when specified in :autoload_plugins" do
-      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
-      allow(YARD::Config).to receive(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
-      expect(YARD::Config).to receive(:require).with('yard-plugin').and_return(true)
-      expect(YARD::Config.load_plugins).to be true
-    end
-
-    it "parses --plugin from command line arguments" do
-      expect(YARD::Config).to receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
-      expect(YARD::Config).to receive(:load_plugin).with('foo').and_return(true)
-      expect(YARD::Config).to receive(:load_plugin).with('bar').and_return(true)
-      expect(YARD::Config.load_plugins).to be true
-    end
-
-    it "loads --plugin arguments from .yardopts" do
-      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return(true)
-      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
-      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
-      expect(File).to receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return('--plugin foo')
-      expect(YARD::Config).to receive(:load_plugin).with('foo')
-      YARD::Config.load
-    end
-
-    it "loads any gem plugins starting with 'yard_' or 'yard-'" do
-      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
-      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
-      plugins = {
-        'yard' => double('yard'),
-        'yard_plugin' => double('yard_plugin'),
-        'yard-plugin' => double('yard-plugin'),
-        'my-yard-plugin' => double('yard-plugin'),
-        'rspec' => double('rspec')
-      }
-      plugins.each do |k, v|
-        expect(v).to receive(:name).at_least(1).times.and_return(k)
-      end
-
-      expect(YARD::GemIndex).to receive(:each) {|&b| plugins.values.each(&b) }
-      expect(YARD::Config).to receive(:load_plugin).with('yard_plugin').and_return(false)
-      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_return(true)
-      expect(YARD::Config.load_plugins).to be true
-    end
-
-    it "logs an error if a gem raises an error" do
-      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
-      plugins = {
-        'yard-plugin' => double('yard-plugin')
-      }
-      plugins.each do |k, v|
-        expect(v).to receive(:name).at_least(1).times.and_return(k)
-      end
-
-      expect(YARD::GemIndex).to receive(:each) {|&b| plugins.values.each(&b) }
-      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
-      expect(log).to receive(:error).with(/Error loading plugin 'yard-plugin'/)
-      expect(YARD::Config.load_plugins).to be false
-    end
-  end
-end
+# frozen_string_literal: true
+require 'yaml'
+
+RSpec.describe YARD::Config do
+  describe ".load" do
+    before do
+      expect(File).to receive(:file?).twice.with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+    end
+
+    it "uses default options if no ~/.yard/config is found" do
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      YARD::Config.load
+      expect(YARD::Config.options).to eq YARD::Config::DEFAULT_CONFIG_OPTIONS
+    end
+
+    it "overwrites options with data in ~/.yard/config" do
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(true)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(YAML).to receive(:load_file).with(YARD::Config::CONFIG_FILE).and_return('test' => true)
+      YARD::Config.load
+      expect(YARD::Config.options[:test]).to be true
+    end
+
+    it "ignores any plugins specified in '~/.yard/ignored_plugins'" do
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(true)
+      expect(File).to receive(:read).with(YARD::Config::IGNORED_PLUGINS).and_return('yard-plugin plugin2')
+      YARD::Config.load
+      expect(YARD::Config.options[:ignored_plugins]).to eq ['yard-plugin', 'yard-plugin2']
+      expect(YARD::Config).not_to receive(:require).with('yard-plugin2')
+      expect(YARD::Config.load_plugin('yard-plugin2')).to be false
+    end
+
+    it "loads safe_mode setting from --safe command line option" do
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      ARGV.replace(['--safe'])
+      YARD::Config.load
+      expect(YARD::Config.options[:safe_mode]).to be true
+      ARGV.replace([''])
+    end
+  end
+
+  describe ".save" do
+    it "saves options to config file" do
+      allow(YARD::Config).to receive(:options).and_return(:a => 1, :b => %w(a b c))
+      file = double(:file)
+      expect(File).to receive(:open).with(YARD::Config::CONFIG_FILE, 'w').and_yield(file)
+      expect(file).to receive(:write).with(YAML.dump(:a => 1, :b => %w(a b c)))
+      YARD::Config.save
+    end
+  end
+
+  describe ".load_plugin" do
+    it "loads a plugin by 'name' as 'yard-name'" do
+      expect(YARD::Config).to receive(:require).with('yard-foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('foo')).to be true
+    end
+
+    it "does not load plugins like 'doc-*'" do
+      expect(YARD::Config).not_to receive(:require).with('yard-doc-core')
+      YARD::Config.load_plugin('doc-core')
+      YARD::Config.load_plugin('yard-doc-core')
+    end
+
+    it "loads plugin by 'yard-name' as 'yard-name'" do
+      expect(YARD::Config).to receive(:require).with('yard-foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('yard-foo')).to be true
+    end
+
+    it "loads plugin by 'yard_name' as 'yard_name'" do
+      expect(YARD::Config).to receive(:require).with('yard_foo')
+      expect(log).to receive(:debug).with(/Loading plugin 'yard_foo'/).once
+      log.show_backtraces = false
+      expect(YARD::Config.load_plugin('yard_foo')).to be true
+    end
+
+    it "logs error if plugin is not found" do
+      expect(YARD::Config).to receive(:require).with('yard-foo').and_raise(LoadError)
+      expect(log).to receive(:error).with(/Error loading plugin 'yard-foo'/).once
+      expect(YARD::Config.load_plugin('yard-foo')).to be false
+    end
+
+    it "sanitizes plugin name (remove /'s)" do
+      expect(YARD::Config).to receive(:require).with('yard-foofoo')
+      expect(YARD::Config.load_plugin('foo/foo')).to be true
+    end
+
+    it "ignores plugins in :ignore_plugins" do
+      allow(YARD::Config).to receive(:options).and_return(:ignored_plugins => ['yard-foo', 'yard-bar'])
+      expect(YARD::Config.load_plugin('foo')).to be false
+      expect(YARD::Config.load_plugin('bar')).to be false
+    end
+  end
+
+  describe ".load_plugins" do
+    it "loads gem plugins if :load_plugins is true" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      allow(YARD::Config).to receive(:load_plugin)
+      expect(YARD::Config).to receive(:require).with('rubygems')
+      YARD::Config.load_plugins
+    end
+
+    it "ignores gem loading if RubyGems cannot load" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      expect(YARD::Config).to receive(:require).with('rubygems').and_raise(LoadError)
+      expect(YARD::Config.load_plugins).to be false
+    end
+
+    it "loads certain plugins automatically when specified in :autoload_plugins" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => false, :ignored_plugins => [], :autoload_plugins => ['yard-plugin'])
+      expect(YARD::Config).to receive(:require).with('yard-plugin').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
+    end
+
+    it "parses --plugin from command line arguments" do
+      expect(YARD::Config).to receive(:arguments).at_least(1).times.and_return(%w(--plugin foo --plugin bar a b c))
+      expect(YARD::Config).to receive(:load_plugin).with('foo').and_return(true)
+      expect(YARD::Config).to receive(:load_plugin).with('bar').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
+    end
+
+    it "loads --plugin arguments from .yardopts" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return(true)
+      expect(File).to receive(:file?).with(YARD::Config::CONFIG_FILE).and_return(false)
+      expect(File).to receive(:file?).with(YARD::Config::IGNORED_PLUGINS).and_return(false)
+      expect(File).to receive(:read_binary).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).twice.and_return('--plugin foo')
+      expect(YARD::Config).to receive(:load_plugin).with('foo')
+      YARD::Config.load
+    end
+
+    it "loads any gem plugins starting with 'yard_' or 'yard-'" do
+      expect(File).to receive(:file?).with(CLI::Yardoc::DEFAULT_YARDOPTS_FILE).and_return(false)
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => ['yard_plugin'], :autoload_plugins => [])
+      plugins = {
+        'yard' => double('yard'),
+        'yard_plugin' => double('yard_plugin'),
+        'yard-plugin' => double('yard-plugin'),
+        'my-yard-plugin' => double('yard-plugin'),
+        'rspec' => double('rspec')
+      }
+      plugins.each do |k, v|
+        expect(v).to receive(:name).at_least(1).times.and_return(k)
+      end
+
+      expect(YARD::GemIndex).to receive(:each) {|&b| plugins.values.each(&b) }
+      expect(YARD::Config).to receive(:load_plugin).with('yard_plugin').and_return(false)
+      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_return(true)
+      expect(YARD::Config.load_plugins).to be true
+    end
+
+    it "logs an error if a gem raises an error" do
+      allow(YARD::Config).to receive(:options).and_return(:load_plugins => true, :ignored_plugins => [], :autoload_plugins => [])
+      plugins = {
+        'yard-plugin' => double('yard-plugin')
+      }
+      plugins.each do |k, v|
+        expect(v).to receive(:name).at_least(1).times.and_return(k)
+      end
+
+      expect(YARD::GemIndex).to receive(:each) {|&b| plugins.values.each(&b) }
+      expect(YARD::Config).to receive(:load_plugin).with('yard-plugin').and_raise(Gem::LoadError)
+      expect(log).to receive(:error).with(/Error loading plugin 'yard-plugin'/)
+      expect(YARD::Config.load_plugins).to be false
+    end
+  end
+end