yard 0.9.18 → 0.9.19

data/spec/code_objects/macro_object_spec.rb

@@ -1,150 +1,150 @@
-# 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
+# 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 +1,184 @@
-# 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
+# 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