yard 0.9.18 → 0.9.19

data/spec/code_objects/module_object_spec.rb

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

data/spec/code_objects/namespace_object_spec.rb

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