yard 0.9.18 → 0.9.19

data/spec/handlers/class_condition_handler_spec.rb

@@ -1,87 +1,87 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
-  before(:all) { parse_file :class_condition_handler_001, __FILE__ }
-
-  def verify_method(*names)
-    names.each {|name| expect(Registry.at("A##{name}")).not_to be nil }
-    names.each {|name| expect(Registry.at("A##{name}not")).to be nil }
-  end
-
-  def no_undoc_error(code)
-    expect { StubbedSourceParser.parse_string(code) }.not_to raise_error
-  end
-
-  it "parses all unless blocks for complex conditions" do
-    verify_method :g
-  end
-
-  it "does not parse conditionals inside methods" do
-    verify_method :h
-  end
-
-  it "only parses then block if condition is literal value `true`" do
-    verify_method :p
-  end
-
-  it "only parses then block if condition is literal integer != 0" do
-    verify_method :o
-  end
-
-  it "inverts block to parse for literal condition if it's an unless block" do
-    verify_method :e
-  end
-
-  it "handles conditions such as 'defined? VALUE'" do
-    verify_method :j, :k
-  end
-
-  it "parses all if/elsif blocks for complex conditions" do
-    verify_method :a, :b, :c, :d
-  end
-
-  it "parses else block if condition is literal value `false`" do
-    verify_method :q
-  end
-
-  it "only parses else block if condition is literal integer == 0" do
-    verify_method :n
-  end
-
-  it "maintains visibility and scope state inside condition" do
-    expect(Registry.at('A#m').visibility).to eq :private
-    expect(Registry.at('A#mnot').visibility).to eq :private
-  end
-
-  it "does not fail on complex conditions" do
-    expect(log).not_to receive(:warn)
-    expect(log).not_to receive(:error)
-    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
-    no_undoc_error(<<-eof)
-      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
-        'String'
-      TEST
-    eof
-    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
-  end
-
-  it "only parses identifiers or namespaces from defined? expressions" do
-    module A
-      @@value = nil
-      def self.b(value) @@value = value end
-      def self.value; @@value end
-    end
-
-    YARD.parse_string <<-eof
-      if defined? A.b(42).to_i
-        class Foo; end
-      else
-        class Bar; end
-      end
-    eof
-    expect(A.value).to be_nil
-    expect(YARD::Registry.at('Foo')).not_to be_nil
-    expect(YARD::Registry.at('Bar')).not_to be_nil
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassConditionHandler" do
+  before(:all) { parse_file :class_condition_handler_001, __FILE__ }
+
+  def verify_method(*names)
+    names.each {|name| expect(Registry.at("A##{name}")).not_to be nil }
+    names.each {|name| expect(Registry.at("A##{name}not")).to be nil }
+  end
+
+  def no_undoc_error(code)
+    expect { StubbedSourceParser.parse_string(code) }.not_to raise_error
+  end
+
+  it "parses all unless blocks for complex conditions" do
+    verify_method :g
+  end
+
+  it "does not parse conditionals inside methods" do
+    verify_method :h
+  end
+
+  it "only parses then block if condition is literal value `true`" do
+    verify_method :p
+  end
+
+  it "only parses then block if condition is literal integer != 0" do
+    verify_method :o
+  end
+
+  it "inverts block to parse for literal condition if it's an unless block" do
+    verify_method :e
+  end
+
+  it "handles conditions such as 'defined? VALUE'" do
+    verify_method :j, :k
+  end
+
+  it "parses all if/elsif blocks for complex conditions" do
+    verify_method :a, :b, :c, :d
+  end
+
+  it "parses else block if condition is literal value `false`" do
+    verify_method :q
+  end
+
+  it "only parses else block if condition is literal integer == 0" do
+    verify_method :n
+  end
+
+  it "maintains visibility and scope state inside condition" do
+    expect(Registry.at('A#m').visibility).to eq :private
+    expect(Registry.at('A#mnot').visibility).to eq :private
+  end
+
+  it "does not fail on complex conditions" do
+    expect(log).not_to receive(:warn)
+    expect(log).not_to receive(:error)
+    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
+    no_undoc_error(<<-eof)
+      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
+        'String'
+      TEST
+    eof
+    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
+  end
+
+  it "only parses identifiers or namespaces from defined? expressions" do
+    module A
+      @@value = nil
+      def self.b(value) @@value = value end
+      def self.value; @@value end
+    end
+
+    YARD.parse_string <<-eof
+      if defined? A.b(42).to_i
+        class Foo; end
+      else
+        class Bar; end
+      end
+    eof
+    expect(A.value).to be_nil
+    expect(YARD::Registry.at('Foo')).not_to be_nil
+    expect(YARD::Registry.at('Bar')).not_to be_nil
+  end
+end

data/spec/handlers/class_handler_spec.rb

@@ -1,247 +1,247 @@
-# frozen_string_literal: true
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
-  before(:all) { parse_file :class_handler_001, __FILE__ }
-
-  it "parses a class block with docstring" do
-    expect(P("A").docstring).to eq "Docstring"
-  end
-
-  it "handles complex class names" do
-    expect(P("A::B::C")).not_to eq nil
-  end
-
-  it "handles the subclassing syntax" do
-    expect(P("A::B::C").superclass).to eq P(:String)
-    expect(P("A::X").superclass).to eq Registry.at("A::B::C")
-  end
-
-  it "interprets class << self as a class level block" do
-    expect(P("A.classmethod1")).not_to eq nil
-  end
-
-  it "interprets class << ClassName as a class level block in ClassName's namespace" do
-    expect(P("A::B::C.Hello")).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "makes visibility public when parsing a block" do
-    expect(P("A::B::C#method1").visibility).to eq :public
-  end
-
-  it "sets superclass type to :class if it is a Proxy" do
-    expect(P("A::B::C").superclass.type).to eq :class
-  end
-
-  it "looks for a superclass before creating the class if it shares the same name" do
-    expect(P('B::A').superclass).to eq P('A')
-  end
-
-  it "handles class definitions in the form ::ClassName" do
-    expect(Registry.at("MyRootClass")).not_to be nil
-  end
-
-  it "handles superclass as a constant-style method (camping style < R /path/)" do
-    expect(P('Test1').superclass).to eq P(:R)
-    expect(P('Test2').superclass).to eq P(:R)
-    expect(P('Test6').superclass).to eq P(:NotDelegateClass)
-  end
-
-  it "handles superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
-    expect(P('Test3').superclass).to eq P(:Struct)
-    expect(P('Test4').superclass).to eq P(:OStruct)
-  end
-
-  it "handles DelegateClass(CLASSNAME) superclass syntax" do
-    expect(P('Test5').superclass).to eq P(:Array)
-  end
-
-  it "handles a superclass of the same name in the form ::ClassName" do
-    expect(P('Q::Logger').superclass).to eq P(:Logger)
-    expect(P('Q::Foo').superclass).not_to eq P('Q::Logger')
-  end
-
-  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
-    it "raises an UndocumentableError for invalid class '#{klass}'" do
-      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
-    end
-  end
-
-  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
-      expect(YARD::CodeObjects::ClassObject).to receive(:new).with(Registry.root, 'A')
-      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
-      expect(Registry.at('A').superclass).to eq P(:Object)
-    end
-  end
-
-  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
-      with_parser(:ruby18) do
-        undoc_error <<-eof
-          CONST = #{klass}
-          class << CONST; end
-        eof
-      end
-      expect(Registry.at(klass)).to be nil
-    end
-  end
-
-  it "documents 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
-    expect(Registry.at('String.classmethod')).not_to be nil
-  end
-
-  it "allows class << SomeRubyClass to create the class if it does not exist" do
-    expect(Registry.at('Symbol.toString')).not_to be nil
-  end
-
-  it "documents 'class Exception' without running into superclass issues" do
-    Parser::SourceParser.parse_string <<-eof
-      class Exception
-      end
-    eof
-    expect(Registry.at(:Exception)).not_to be nil
-  end
-
-  it "documents 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
-    expect(Registry.at(:RT)).not_to be nil
-    expect(Registry.at(:RT).superclass).to eq P('XX::RT')
-  end
-
-  it "does not overwrite docstring with an empty one" do
-    expect(Registry.at(:Zebra).docstring).to eq "Docstring 2"
-  end
-
-  it "turns 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
-    obj = Registry.at("Point")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:x, :y, :z].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "turns 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
-    obj = Registry.at("AnotherPoint")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-
-    expect(Registry.at("XPoint")).to be nil
-  end
-
-  it "creates a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
-    obj = Registry.at("Struct::XPoint")
-    expect(obj).not_to be nil
-  end
-
-  it "attaches attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
-    obj = Registry.at("Struct::XPoint")
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "uses @attr to set attribute descriptions on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#input")
-    expect(obj.docstring).to eq "the input stream"
-  end
-
-  it "uses @attr to set attribute types on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#someproc")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Proc", "#call"]
-  end
-
-  it "defaults types unspecified by @attr to Object on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#mode")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Object"]
-  end
-
-  it "creates parameters for writers of Struct subclass's attributes" do
-    obj = Registry.at("DoccedStruct#input=")
-    expect(obj.tags(:param).size).to eq 1
-    expect(obj.tag(:param).types).to eq ["IO"]
-  end
-
-  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
-    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
-      it "defines both readers and writers when @attr is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:first][:read]).not_to be nil
-        expect(attrs[:first][:write]).not_to be nil
-      end
-
-      it "defines only a reader when only @attr_reader is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:second][:read]).not_to be nil
-        expect(attrs[:second][:write]).to be nil
-      end
-
-      it "defines only a writer when only @attr_writer is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:third][:read]).to be nil
-        expect(attrs[:third][:write]).not_to be nil
-      end
-
-      it "defines a reader with correct return types when @attr_reader is used on Structs" do
-        obj = Registry.at("#{struct}#second")
-        expect(obj.tag(:return).types).to eq ["Fixnum"]
-      end
-
-      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
-        obj = Registry.at("#{struct}#third=")
-        expect(obj.tag(:param).types).to eq ["Array"]
-      end
-
-      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:fourth][:read]).not_to be nil
-        expect(attrs[:fourth][:write]).not_to be nil
-      end
-
-      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth")
-        expect(obj.tag(:return).types).to eq ["#read"]
-      end
-
-      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth=")
-        expect(obj.tag(:param).types).to eq ["IO"]
-      end
-
-      it "extracts text from @attr_reader" do
-        expect(Registry.at("#{struct}#fourth").docstring).to eq "returns a proc that reads"
-      end
-
-      it "extracts text from @attr_writer" do
-        expect(Registry.at("#{struct}#fourth=").docstring).to eq "sets the proc that writes stuff"
-      end
-    end
-  end
-
-  it "inherits from a regular struct" do
-    expect(Registry.at('RegularStruct').superclass).to eq P(:Struct)
-    expect(Registry.at('RegularStruct2').superclass).to eq P(:Struct)
-  end
-
-  it "handles inheritance from 'self'" do
-    expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
-  end
-end
+# frozen_string_literal: true
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
+  before(:all) { parse_file :class_handler_001, __FILE__ }
+
+  it "parses a class block with docstring" do
+    expect(P("A").docstring).to eq "Docstring"
+  end
+
+  it "handles complex class names" do
+    expect(P("A::B::C")).not_to eq nil
+  end
+
+  it "handles the subclassing syntax" do
+    expect(P("A::B::C").superclass).to eq P(:String)
+    expect(P("A::X").superclass).to eq Registry.at("A::B::C")
+  end
+
+  it "interprets class << self as a class level block" do
+    expect(P("A.classmethod1")).not_to eq nil
+  end
+
+  it "interprets class << ClassName as a class level block in ClassName's namespace" do
+    expect(P("A::B::C.Hello")).to be_instance_of(CodeObjects::MethodObject)
+  end
+
+  it "makes visibility public when parsing a block" do
+    expect(P("A::B::C#method1").visibility).to eq :public
+  end
+
+  it "sets superclass type to :class if it is a Proxy" do
+    expect(P("A::B::C").superclass.type).to eq :class
+  end
+
+  it "looks for a superclass before creating the class if it shares the same name" do
+    expect(P('B::A').superclass).to eq P('A')
+  end
+
+  it "handles class definitions in the form ::ClassName" do
+    expect(Registry.at("MyRootClass")).not_to be nil
+  end
+
+  it "handles superclass as a constant-style method (camping style < R /path/)" do
+    expect(P('Test1').superclass).to eq P(:R)
+    expect(P('Test2').superclass).to eq P(:R)
+    expect(P('Test6').superclass).to eq P(:NotDelegateClass)
+  end
+
+  it "handles superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
+    expect(P('Test3').superclass).to eq P(:Struct)
+    expect(P('Test4').superclass).to eq P(:OStruct)
+  end
+
+  it "handles DelegateClass(CLASSNAME) superclass syntax" do
+    expect(P('Test5').superclass).to eq P(:Array)
+  end
+
+  it "handles a superclass of the same name in the form ::ClassName" do
+    expect(P('Q::Logger').superclass).to eq P(:Logger)
+    expect(P('Q::Foo').superclass).not_to eq P('Q::Logger')
+  end
+
+  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
+    it "raises an UndocumentableError for invalid class '#{klass}'" do
+      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
+    end
+  end
+
+  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
+    it "raises an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
+      expect(YARD::CodeObjects::ClassObject).to receive(:new).with(Registry.root, 'A')
+      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
+      expect(Registry.at('A').superclass).to eq P(:Object)
+    end
+  end
+
+  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
+    it "raises an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
+      with_parser(:ruby18) do
+        undoc_error <<-eof
+          CONST = #{klass}
+          class << CONST; end
+        eof
+      end
+      expect(Registry.at(klass)).to be nil
+    end
+  end
+
+  it "documents 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
+    expect(Registry.at('String.classmethod')).not_to be nil
+  end
+
+  it "allows class << SomeRubyClass to create the class if it does not exist" do
+    expect(Registry.at('Symbol.toString')).not_to be nil
+  end
+
+  it "documents 'class Exception' without running into superclass issues" do
+    Parser::SourceParser.parse_string <<-eof
+      class Exception
+      end
+    eof
+    expect(Registry.at(:Exception)).not_to be nil
+  end
+
+  it "documents 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
+    expect(Registry.at(:RT)).not_to be nil
+    expect(Registry.at(:RT).superclass).to eq P('XX::RT')
+  end
+
+  it "does not overwrite docstring with an empty one" do
+    expect(Registry.at(:Zebra).docstring).to eq "Docstring 2"
+  end
+
+  it "turns 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
+    obj = Registry.at("Point")
+    expect(obj).to be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:x, :y, :z].each do |key|
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
+    end
+  end
+
+  it "turns 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
+    obj = Registry.at("AnotherPoint")
+    expect(obj).to be_kind_of(CodeObjects::ClassObject)
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
+    end
+
+    expect(Registry.at("XPoint")).to be nil
+  end
+
+  it "creates a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
+    obj = Registry.at("Struct::XPoint")
+    expect(obj).not_to be nil
+  end
+
+  it "attaches attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
+    obj = Registry.at("Struct::XPoint")
+    attrs = obj.attributes[:instance]
+    [:a, :b, :c].each do |key|
+      expect(attrs).to have_key(key)
+      expect(attrs[key][:read]).not_to be nil
+      expect(attrs[key][:write]).not_to be nil
+    end
+  end
+
+  it "uses @attr to set attribute descriptions on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#input")
+    expect(obj.docstring).to eq "the input stream"
+  end
+
+  it "uses @attr to set attribute types on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#someproc")
+    expect(obj).not_to be nil
+    expect(obj.tag(:return)).not_to be nil
+    expect(obj.tag(:return).types).to eq ["Proc", "#call"]
+  end
+
+  it "defaults types unspecified by @attr to Object on Struct subclasses" do
+    obj = Registry.at("DoccedStruct#mode")
+    expect(obj).not_to be nil
+    expect(obj.tag(:return)).not_to be nil
+    expect(obj.tag(:return).types).to eq ["Object"]
+  end
+
+  it "creates parameters for writers of Struct subclass's attributes" do
+    obj = Registry.at("DoccedStruct#input=")
+    expect(obj.tags(:param).size).to eq 1
+    expect(obj.tag(:param).types).to eq ["IO"]
+  end
+
+  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
+    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
+      it "defines both readers and writers when @attr is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        expect(attrs[:first][:read]).not_to be nil
+        expect(attrs[:first][:write]).not_to be nil
+      end
+
+      it "defines only a reader when only @attr_reader is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        expect(attrs[:second][:read]).not_to be nil
+        expect(attrs[:second][:write]).to be nil
+      end
+
+      it "defines only a writer when only @attr_writer is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        expect(attrs[:third][:read]).to be nil
+        expect(attrs[:third][:write]).not_to be nil
+      end
+
+      it "defines a reader with correct return types when @attr_reader is used on Structs" do
+        obj = Registry.at("#{struct}#second")
+        expect(obj.tag(:return).types).to eq ["Fixnum"]
+      end
+
+      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
+        obj = Registry.at("#{struct}#third=")
+        expect(obj.tag(:param).types).to eq ["Array"]
+      end
+
+      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        expect(attrs[:fourth][:read]).not_to be nil
+        expect(attrs[:fourth][:write]).not_to be nil
+      end
+
+      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth")
+        expect(obj.tag(:return).types).to eq ["#read"]
+      end
+
+      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth=")
+        expect(obj.tag(:param).types).to eq ["IO"]
+      end
+
+      it "extracts text from @attr_reader" do
+        expect(Registry.at("#{struct}#fourth").docstring).to eq "returns a proc that reads"
+      end
+
+      it "extracts text from @attr_writer" do
+        expect(Registry.at("#{struct}#fourth=").docstring).to eq "sets the proc that writes stuff"
+      end
+    end
+  end
+
+  it "inherits from a regular struct" do
+    expect(Registry.at('RegularStruct').superclass).to eq P(:Struct)
+    expect(Registry.at('RegularStruct2').superclass).to eq P(:Struct)
+  end
+
+  it "handles inheritance from 'self'" do
+    expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
+  end
+end