yard 0.9.24 → 0.9.25

data/spec/code_objects/macro_object_spec.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::MacroObject do
-  before do
-    Registry.clear
-  end
-
-  describe ".create" do
-    def create(*args) MacroObject.create(*args) end
-
-    it "creates an object" do
-      create('foo', '')
-      obj = Registry.at('.macro.foo')
-      expect(obj).not_to be nil
-    end
-
-    it "uses identity map" do
-      obj1 = create('foo', '')
-      obj2 = create('foo', '')
-      expect(obj1.object_id).to eq obj2.object_id
-    end
-
-    it "allows specifying of macro data" do
-      obj = create('foo', 'MACRODATA')
-      expect(obj.macro_data).to eq 'MACRODATA'
-    end
-
-    context "if a method object is provided" do
-      it "attaches it" do
-        obj = create('foo', 'MACRODATA', P('Foo.property'))
-        expect(obj.method_object).to eq P('Foo.property')
-        expect(obj).to be_attached
-      end
-    end
-  end
-
-  describe ".find" do
-    before { MacroObject.create('foo', 'DATA') }
-
-    it "searches for an object by name" do
-      expect(MacroObject.find('foo').macro_data).to eq 'DATA'
-    end
-
-    it "accepts Symbol" do
-      expect(MacroObject.find(:foo).macro_data).to eq 'DATA'
-    end
-  end
-
-  describe ".find_or_create" do
-    it "looks up name if @!macro is present and find object" do
-      macro1 = MacroObject.create('foo', 'FOO')
-      macro2 = MacroObject.find_or_create('foo', "a b c")
-      expect(macro1).to eq macro2
-    end
-
-    it "creates new macro if macro by that name does not exist" do
-      MacroObject.find_or_create('foo', "@!method $1")
-      expect(MacroObject.find('foo').macro_data).to eq "@!method $1"
-    end
-  end
-
-  describe ".apply" do
-    let(:args) { %w(foo a b c) }
-
-    def apply(comments)
-      MacroObject.apply(comments, args)
-    end
-
-    it "only expands macros if @macro is present" do
-      expect(apply("$1$2$3")).to eq "$1$2$3"
-    end
-
-    it "handles macro text inside block" do
-      expect(apply("@!macro\n  foo$1$2$3\nfoobaz")).to eq "fooabc\nfoobaz"
-    end
-
-    it "appends docstring to existing macro" do
-      MacroObject.create('name', '$3$2$1')
-      result = MacroObject.apply("@!macro name\nfoobar", args)
-      expect(result).to eq "cba\nfoobar"
-    end
-
-    it "uses only non-macro data if docstring is an existing macro" do
-      data = "@!macro name\n  $3$2$1\nEXTRA"
-      result = MacroObject.apply(data, args, 'SOURCE')
-      expect(result).to eq "cba\nEXTRA"
-      expect(MacroObject.apply("@!macro name\nFOO", args)).to eq "cba\nFOO"
-    end
-
-    it "creates macros if they don't exist" do
-      result = MacroObject.apply("@!macro name\n  foo!$1", args, 'SOURCE')
-      expect(result).to eq "foo!a"
-      expect(MacroObject.find('name').macro_data).to eq 'foo!$1'
-    end
-
-    it "keeps other tags" do
-      expect(apply("@!macro\n  foo$1$2$3\n@param name foo\nfoo")).to eq(
-        "fooabc\nfoo\n@param name\n  foo"
-      )
-    end
-  end
-
-  describe ".expand" do
-    def expand(comments)
-      args = %w(foo a b c)
-      full_line = 'foo :bar, :baz'
-      MacroObject.expand(comments, args, full_line)
-    end
-
-    it "allows escaping of macro syntax" do
-      expect(expand("$1\\$2$3")).to eq "a$2c"
-    end
-
-    it "replaces $* with the whole statement" do
-      expect(expand("$* ${*}")).to eq "foo :bar, :baz foo :bar, :baz"
-    end
-
-    it "replaces $0 with method name" do
-      expect(expand("$0 ${0}")).to eq "foo foo"
-    end
-
-    it "replaces all $N values with the Nth argument in the method call" do
-      expect(expand("$1$2$3${3}\nfoobar")).to eq "abcc\nfoobar"
-    end
-
-    it "replaces ${N-M} ranges with N-M arguments (incl. commas)" do
-      expect(expand("${1-2}x")).to eq "a, bx"
-    end
-
-    it "handles open ended ranges (${N-})" do
-      expect(expand("${2-}")).to eq "b, c"
-    end
-
-    it "handles negative indexes ($-N)" do
-      expect(expand("$-1 ${-2-} ${-2--2}")).to eq "c b, c b"
-    end
-
-    it "accepts Docstring objects" do
-      expect(expand(Docstring.new("$1\n@param name foo"))).to eq "a\n@param name foo"
-    end
-  end
-
-  describe "#expand" do
-    it "expands a macro given its data" do
-      macro = MacroObject.create_docstring('foo', '$1 $2 THREE!')
-      expect(macro.expand(['NAME', 'ONE', 'TWO'])).to eq "ONE TWO THREE!"
-    end
-  end
-end

data/spec/code_objects/method_object_spec.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::MethodObject do
-  before do
-    Registry.clear
-    @yard = ModuleObject.new(:root, :YARD)
-  end
-
-  context "for an instance method in the root" do
-    it "has a path of testing" do
-      meth = MethodObject.new(:root, :testing)
-      expect(meth.path).to eq "#testing"
-    end
-  end
-
-  context "for an instance method in YARD" do
-    it "has a path of YARD#testing" do
-      meth = MethodObject.new(@yard, :testing)
-      expect(meth.path).to eq "YARD#testing"
-    end
-  end
-
-  context "for a class method in YARD" do
-    it "has a path of YARD.testing" do
-      meth = MethodObject.new(@yard, :testing, :class)
-      expect(meth.path).to eq "YARD.testing"
-    end
-  end
-
-  context "for a class method added to root namespace" do
-    it "has a path of ::testing (note the ::)" do
-      meth = MethodObject.new(:root, :testing, :class)
-      expect(meth.path).to eq "::testing"
-    end
-  end
-
-  it "exists in the registry after successful creation" do
-    MethodObject.new(@yard, :something, :class)
-    expect(Registry.at("YARD.something")).not_to be nil
-    expect(Registry.at("YARD#something")).to be nil
-    expect(Registry.at("YARD::something")).to be nil
-    MethodObject.new(@yard, :somethingelse)
-    expect(Registry.at("YARD#somethingelse")).not_to be nil
-  end
-
-  it "allows #scope to be changed after creation" do
-    obj = MethodObject.new(@yard, :something, :class)
-    expect(Registry.at("YARD.something")).not_to be nil
-    obj.scope = :instance
-    expect(Registry.at("YARD.something")).to be nil
-    expect(Registry.at("YARD#something")).not_to be nil
-  end
-
-  it "creates object in :class scope if scope is :module" do
-    obj = MethodObject.new(@yard, :module_func, :module)
-    expect(obj.scope).to eq :class
-    expect(obj.visibility).to eq :public
-    expect(Registry.at('YARD.module_func')).not_to be nil
-  end
-
-  it "creates second private instance method if scope is :module" do
-    MethodObject.new(@yard, :module_func, :module)
-    obj = Registry.at('YARD#module_func')
-    expect(obj).not_to be nil
-    expect(obj.visibility).to eq :private
-    expect(obj.scope).to eq :instance
-  end
-
-  it "yields block to second method if scope is :module" do
-    MethodObject.new(@yard, :module_func, :module) do |o|
-      o.docstring = 'foo'
-    end
-    expect(Registry.at('YARD.module_func').docstring).to eq 'foo'
-    expect(Registry.at('YARD#module_func').docstring).to eq 'foo'
-  end
-
-  describe "#name" do
-    it "shows a prefix for an instance method when prefix=true" do
-      obj = MethodObject.new(nil, :something)
-      expect(obj.name(true)).to eq "#something"
-    end
-
-    it "never shows a prefix for a class method" do
-      obj = MethodObject.new(nil, :something, :class)
-      expect(obj.name).to eq :something
-      expect(obj.name(true)).to eq "something"
-    end
-  end
-
-  describe "#is_attribute?" do
-    it "only returns true if attribute is set in namespace for read/write" do
-      obj = MethodObject.new(@yard, :foo)
-      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      expect(obj.is_attribute?).to be true
-      expect(MethodObject.new(@yard, :foo=).is_attribute?).to be false
-    end
-  end
-
-  describe "#attr_info" do
-    it "returns attribute info if namespace is available" do
-      obj = MethodObject.new(@yard, :foo)
-      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      expect(obj.attr_info).to eq @yard.attributes[:instance][:foo]
-    end
-
-    it "returns nil if namespace is proxy" do
-      MethodObject.new(P(:ProxyClass), :foo)
-      expect(MethodObject.new(@yard, :foo).attr_info).to eq nil
-    end
-
-    it "returns nil if meth is not an attribute" do
-      expect(MethodObject.new(@yard, :notanattribute).attr_info).to eq nil
-    end
-  end
-
-  describe "#writer?" do
-    it "returns true if method is a writer attribute" do
-      obj = MethodObject.new(@yard, :foo=)
-      @yard.attributes[:instance][:foo] = {:read => nil, :write => obj}
-      expect(obj.writer?).to be true
-      expect(MethodObject.new(@yard, :NOTfoo=).writer?).to be false
-    end
-  end
-
-  describe "#reader?" do
-    it "returns true if method is a reader attribute" do
-      obj = MethodObject.new(@yard, :foo)
-      @yard.attributes[:instance][:foo] = {:read => obj, :write => nil}
-      expect(obj.reader?).to be true
-      expect(MethodObject.new(@yard, :NOTfoo).reader?).to be false
-    end
-  end
-
-  describe "#constructor?" do
-    before { @class = ClassObject.new(:root, :MyClass) }
-
-    it "marks the #initialize method as constructor" do
-      MethodObject.new(@class, :initialize)
-    end
-
-    it "does not mark Klass.initialize as constructor" do
-      expect(MethodObject.new(@class, :initialize, :class).constructor?).to be false
-    end
-
-    it "does not mark module method #initialize as constructor" do
-      expect(MethodObject.new(@yard, :initialize).constructor?).to be false
-    end
-  end
-
-  describe "#overridden_method" do
-    before { Registry.clear }
-
-    it "returns overridden method from mixin first" do
-      YARD.parse_string(<<-eof)
-        module C; def foo; end end
-        class A; def foo; end end
-        class B < A; include C; def foo; end end
-      eof
-      expect(Registry.at('B#foo').overridden_method).to eq Registry.at('C#foo')
-    end
-
-    it "returns overridden method from superclass" do
-      YARD.parse_string(<<-eof)
-        class A; def foo; end end
-        class B < A; def foo; end end
-      eof
-      expect(Registry.at('B#foo').overridden_method).to eq Registry.at('A#foo')
-    end
-
-    it "returns nil if none is found" do
-      YARD.parse_string(<<-eof)
-        class A; end
-        class B < A; def foo; end end
-      eof
-      expect(Registry.at('B#foo').overridden_method).to be nil
-    end
-
-    it "returns nil if namespace is a proxy" do
-      YARD.parse_string "def ARGV.foo; end"
-      expect(Registry.at('ARGV.foo').overridden_method).to be nil
-    end
-  end
-end

data/spec/code_objects/module_object_spec.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::CodeObjects::ModuleObject do
-  describe "#meths" do
-    before do
-      Registry.clear
-
-      # setup the object space:
-      #
-      #   YARD:module
-      #   YARD#foo:method
-      #   YARD#foo2:method
-      #   YARD#xyz:method
-      #   YARD.bar:method
-      #   SomeMod#mixmethod
-      #   SomeMod#xyz:method
-      #
-      @yard = ModuleObject.new(:root, :YARD)
-      MethodObject.new(@yard, :foo)
-      MethodObject.new(@yard, :xyz)
-      MethodObject.new(@yard, :foo2) do |o|
-        o.visibility = :protected
-      end
-      MethodObject.new(@yard, :bar, :class) do |o|
-        o.visibility = :private
-      end
-      @other = ModuleObject.new(:root, :SomeMod)
-      MethodObject.new(@other, :mixmethod)
-      MethodObject.new(@other, :xyz)
-      MethodObject.new(@other, :baz, :class)
-      @another = ModuleObject.new(:root, :AnotherMod)
-      MethodObject.new(@another, :fizz)
-      MethodObject.new(@another, :bar)
-      MethodObject.new(@another, :fazz, :class)
-
-      @yard.instance_mixins << @other
-      @yard.class_mixins << @another
-    end
-
-    it "lists all methods (including mixin methods) via #meths" do
-      meths = @yard.meths
-      expect(meths).to include(P("YARD#foo"))
-      expect(meths).to include(P("YARD#foo2"))
-      expect(meths).to include(P("YARD.bar"))
-      expect(meths).to include(P("SomeMod#mixmethod"))
-      expect(meths).to include(P("AnotherMod#fizz"))
-    end
-
-    it "allows :visibility to be set" do
-      meths = @yard.meths(:visibility => :public)
-      expect(meths).not_to include(P("YARD.bar"))
-      meths = @yard.meths(:visibility => [:public, :private])
-      expect(meths).to include(P("YARD#foo"))
-      expect(meths).to include(P("YARD.bar"))
-      expect(meths).not_to include(P("YARD#foo2"))
-    end
-
-    it "only displays class methods for :scope => :class" do
-      meths = @yard.meths(:scope => :class)
-      expect(meths).not_to include(P("YARD#foo"))
-      expect(meths).not_to include(P("YARD#foo2"))
-      expect(meths).not_to include(P("SomeMod#mixmethod"))
-      expect(meths).not_to include(P("SomeMod.baz"))
-      expect(meths).not_to include(P("AnotherMod#fazz"))
-      expect(meths).to include(P("YARD.bar"))
-      expect(meths).to include(P("AnotherMod#fizz"))
-    end
-
-    it "only displays instance methods for :scope => :class" do
-      meths = @yard.meths(:scope => :instance)
-      expect(meths).to include(P("YARD#foo"))
-      expect(meths).to include(P("YARD#foo2"))
-      expect(meths).to include(P("SomeMod#mixmethod"))
-      expect(meths).not_to include(P("YARD.bar"))
-      expect(meths).not_to include(P("AnotherMod#fizz"))
-    end
-
-    it "allows :included to be set" do
-      meths = @yard.meths(:included => false)
-      expect(meths).not_to include(P("SomeMod#mixmethod"))
-      expect(meths).not_to include(P("AnotherMod#fizz"))
-      expect(meths).to include(P("YARD#foo"))
-      expect(meths).to include(P("YARD#foo2"))
-      expect(meths).to include(P("YARD.bar"))
-    end
-
-    it "chooses the method defined in the class over an included module" do
-      meths = @yard.meths
-      expect(meths).not_to include(P("SomeMod#xyz"))
-      expect(meths).to include(P("YARD#xyz"))
-      expect(meths).not_to include(P("AnotherMod#bar"))
-      expect(meths).to include(P("YARD.bar"))
-
-      meths = @other.meths
-      expect(meths).to include(P("SomeMod#xyz"))
-
-      meths = @another.meths
-      expect(meths).to include(P("AnotherMod#bar"))
-    end
-  end
-
-  describe "#inheritance_tree" do
-    before do
-      Registry.clear
-
-      @mod1 = ModuleObject.new(:root, :Mod1)
-      @mod2 = ModuleObject.new(:root, :Mod2)
-      @mod3 = ModuleObject.new(:root, :Mod3)
-      @mod4 = ModuleObject.new(:root, :Mod4)
-      @mod5 = ModuleObject.new(:root, :Mod5)
-
-      @mod1.instance_mixins << @mod2
-      @mod2.instance_mixins << @mod3
-      @mod3.instance_mixins << @mod4
-      @mod1.instance_mixins << @mod4
-
-      @proxy = P(:SomeProxyClass)
-      @mod5.instance_mixins << @proxy
-    end
-
-    it "shows only itself for an inheritance tree without included modules" do
-      expect(@mod1.inheritance_tree).to eq [@mod1]
-    end
-
-    it "shows proper inheritance tree when modules are included" do
-      expect(@mod1.inheritance_tree(true)).to eq [@mod1, @mod2, @mod3, @mod4]
-    end
-
-    it "does not list inheritance tree of proxy objects in inheritance tree" do
-      expect(@proxy).not_to receive(:inheritance_tree)
-      expect(@mod5.instance_mixins).to eq [@proxy]
-    end
-
-    it "lists class mixins in inheritance tree" do
-      mod = ModuleObject.new(:root, :ClassMethods)
-      recvmod = ModuleObject.new(:root, :ReceivingModule)
-      recvmod.class_mixins << mod
-      expect(recvmod.inheritance_tree(true)).to eq [recvmod, mod]
-    end
-  end
-end