yard 0.9.24 → 0.9.25

data/spec/code_objects/namespace_mapper_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::NamespaceMapper do
-  include YARD::CodeObjects::NamespaceMapper
-
-  describe '#register_separator' do
-    it 'should allow separators to be registered' do
-      register_separator '!', :test_type
-
-      expect(separators_for_type(:test_type)).to eq ['!']
-      expect(types_for_separator('!')).to eq [:test_type]
-
-      unregister_separator_by_type :test_type
-
-      expect(separators_for_type(:test_type)).to be_empty
-      expect(types_for_separator('!')).to be_empty
-    end
-  end
-
-  describe '.on_invalidate' do
-    it 'receives a callback when a new separator is added' do
-      invalidated = false
-      NamespaceMapper.on_invalidate { invalidated = true }
-
-      register_separator '!', :test_type
-      expect(invalidated).to be true
-
-      unregister_separator_by_type :test_type
-    end
-  end
-end

data/spec/code_objects/namespace_object_spec.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::NamespaceObject do
-  before { Registry.clear }
-
-  describe "#child" do
-    it "returns the object matching the name passed in if argument is a Symbol" do
-      obj = NamespaceObject.new(nil, :YARD)
-      other = NamespaceObject.new(obj, :Other)
-      expect(obj.child(:Other)).to eq other
-      expect(obj.child('Other')).to eq other
-    end
-
-    it "looks for attributes matching the object if the argument is a Hash" do
-      obj = NamespaceObject.new(nil, :YARD)
-      NamespaceObject.new(obj, :NotOther)
-      other = NamespaceObject.new(obj, :Other)
-      other.somevalue = 2
-      expect(obj.child(:somevalue => 2)).to eq other
-    end
-  end
-
-  describe "#meths" do
-    it "returns #meths even if parent is a Proxy" do
-      obj = NamespaceObject.new(P(:String), :YARD)
-      expect(obj.meths).to be_empty
-    end
-
-    it "does not list included methods that are already defined in the namespace using #meths" do
-      a = ModuleObject.new(nil, :Mod1)
-      ameth = MethodObject.new(a, :testing)
-      b = ModuleObject.new(nil, :Mod2)
-      bmeth = MethodObject.new(b, :foo)
-      c = NamespaceObject.new(nil, :YARD)
-      cmeth = MethodObject.new(c, :testing)
-      cmeth2 = MethodObject.new(c, :foo)
-      c.instance_mixins << a
-      c.class_mixins << b
-
-      meths = c.meths
-      expect(meths).to include(bmeth)
-      expect(meths).to include(cmeth)
-      expect(meths).to include(cmeth2)
-      expect(meths).not_to include(ameth)
-
-      meths = c.included_meths
-      expect(meths).to include(bmeth)
-      expect(meths).not_to include(ameth)
-      expect(meths).not_to include(cmeth)
-      expect(meths).not_to include(cmeth2)
-    end
-  end
-
-  describe "#included_meths" do
-    it "lists methods mixed into the class scope as class methods" do
-      b = ModuleObject.new(nil, :Mod2)
-      bmeth = MethodObject.new(b, :foo)
-      bmeth2 = MethodObject.new(b, :foo2)
-      c = NamespaceObject.new(nil, :YARD)
-      c.class_mixins << b
-
-      [bmeth, bmeth2].each {|o| expect(o.scope).to eq :instance }
-      meths = c.included_meths(:scope => :class)
-      meths.each {|o| expect(o.scope).to eq :class }
-    end
-
-    it "does not list methods overridden by another included module" do
-      a = ModuleObject.new(nil, :Mod)
-      ameth = MethodObject.new(a, :testing)
-      b = ModuleObject.new(nil, :Mod2)
-      bmeth = MethodObject.new(b, :testing)
-      c = NamespaceObject.new(nil, :YARD)
-      c.instance_mixins.unshift a
-      c.instance_mixins.unshift b
-      c.class_mixins.unshift b
-      c.class_mixins.unshift a
-
-      meths = c.included_meths(:scope => :instance)
-      expect(meths).not_to include(ameth)
-      expect(meths).to include(bmeth)
-
-      meths = c.included_meths(:scope => :class)
-      expect(meths).to include(ameth)
-      expect(meths).not_to include(bmeth)
-    end
-  end
-
-  describe "#class_attributes" do
-    it "lists class attributes" do
-      a = NamespaceObject.new(nil, :Mod)
-      a.attributes[:instance][:a] = {:read => MethodObject.new(a, :a), :write => nil}
-      a.attributes[:instance][:b] = {:read => MethodObject.new(a, :b), :write => nil}
-      a.attributes[:class][:a] = {:read => MethodObject.new(a, :a, :class), :write => nil}
-      expect(a.class_attributes.keys).to include(:a)
-      expect(a.class_attributes.keys).not_to include(:b)
-    end
-  end
-
-  describe "#instance_attributes" do
-    it "lists instance attributes" do
-      a = NamespaceObject.new(nil, :Mod)
-      a.attributes[:instance][:a] = {:read => MethodObject.new(a, :a), :write => nil}
-      a.attributes[:instance][:b] = {:read => MethodObject.new(a, :b), :write => nil}
-      a.attributes[:class][:a] = {:read => MethodObject.new(a, :a, :class), :write => nil}
-      expect(a.instance_attributes.keys).to include(:a)
-      expect(a.instance_attributes.keys).to include(:b)
-    end
-  end
-
-  describe "#constants/#included_constants" do
-    before do
-      Registry.clear
-
-      YARD.parse_string <<-eof
-        module A
-          CONST1 = 1
-          CONST2 = 2
-        end
-
-        module B
-          CONST2 = -2
-          CONST3 = -3
-        end
-
-        class C
-          CONST3 = 3
-          CONST4 = 4
-
-          include A
-          include B
-        end
-      eof
-    end
-
-    it "lists all included constants by default" do
-      consts = P(:C).constants
-      expect(consts).to include(P('A::CONST1'))
-      expect(consts).to include(P('C::CONST4'))
-    end
-
-    it "allows :included to be set to false to ignore included constants" do
-      consts = P(:C).constants(:included => false)
-      expect(consts).not_to include(P('A::CONST1'))
-      expect(consts).to include(P('C::CONST4'))
-    end
-
-    it "does not list an included constant if it is defined in the object" do
-      consts = P(:C).constants
-      expect(consts).to include(P('C::CONST3'))
-      expect(consts).not_to include(P('B::CONST3'))
-    end
-
-    it "does not list an included constant if it is shadowed by another included constant" do
-      consts = P(:C).included_constants
-      expect(consts).to include(P('B::CONST2'))
-      expect(consts).not_to include(P('A::CONST2'))
-    end
-  end
-
-  describe "#included_meths" do
-    it "returns all included methods with :all = true" do
-      YARD.parse_string <<-eof
-        module B; def foo; end end
-        module C; def bar; end end
-        class A; include B; include C; def foo; end; def bar; end end
-      eof
-      expect(Registry.at('A').included_meths(:all => true)).to eq [P('C#bar'), P('B#foo')]
-    end
-  end
-end

data/spec/code_objects/proxy_spec.rb

@@ -1,147 +0,0 @@
-# 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 +0,0 @@
-# frozen_string_literal: true
-
-include CodeObjects

data/spec/config_spec.rb

@@ -1,171 +0,0 @@
-# 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