yard 0.9.23 → 0.9.27

data/spec/handlers/c/method_handler_spec.rb

@@ -1,327 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::MethodHandler do
-  it "registers methods" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_method(mFoo, "bar", bar, 0);
-    eof
-    expect(Registry.at('Foo#bar')).not_to be nil
-    expect(Registry.at('Foo#bar').visibility).to eq :public
-  end
-
-  it "registers private methods" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_private_method(mFoo, "bar", bar, 0);
-    eof
-    expect(Registry.at('Foo#bar')).not_to be nil
-    expect(Registry.at('Foo#bar').visibility).to eq :private
-  end
-
-  it "registers singleton methods" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_singleton_method(mFoo, "bar", bar, 0);
-    eof
-    expect(Registry.at('Foo.bar')).not_to be nil
-    expect(Registry.at('Foo.bar').visibility).to eq :public
-  end
-
-  it "registers module functions" do
-    parse <<-eof
-      /* DOCSTRING
-       * @return [String] foo!
-      */
-      static VALUE bar(VALUE self) { x(); y(); z(); }
-
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_module_function(mFoo, "bar", bar, 0);
-      }
-    eof
-    bar_c = Registry.at('Foo.bar')
-    bar_i = Registry.at('Foo#bar')
-    expect(bar_c).to be_module_function
-    expect(bar_c.visibility).to eq :public
-    expect(bar_c.docstring).to eq "DOCSTRING"
-    expect(bar_c.tag(:return).object).to eq bar_c
-    expect(bar_c.source).to eq "static VALUE bar(VALUE self) { x(); y(); z(); }"
-    expect(bar_i).not_to be_module_function
-    expect(bar_i.visibility).to eq :private
-    expect(bar_i.docstring).to eq "DOCSTRING"
-    expect(bar_i.tag(:return).object).to eq bar_i
-    expect(bar_i.source).to eq bar_c.source
-  end
-
-  it "registers global functions into Kernel" do
-    parse_init 'rb_define_global_function("bar", bar, 0);'
-    expect(Registry.at('Kernel#bar')).not_to be nil
-  end
-
-  it "looks for symbol containing method source" do
-    parse <<-eof
-      static VALUE foo(VALUE self) { x(); y(); z(); }
-      VALUE bar() { a(); b(); c(); }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0);
-        rb_define_method(mFoo, "bar", bar, 0);
-      }
-    eof
-    foo = Registry.at('Foo#foo')
-    bar = Registry.at('Foo#bar')
-    expect(foo.source).to eq "static VALUE foo(VALUE self) { x(); y(); z(); }"
-    expect(foo.file).to eq '(stdin)'
-    expect(foo.line).to eq 1
-    expect(bar.source).to eq "VALUE bar() { a(); b(); c(); }"
-    expect(bar.file).to eq '(stdin)'
-    expect(bar.line).to eq 2
-  end
-
-  it "finds docstrings attached to method symbols" do
-    parse <<-eof
-      /* DOCSTRING */
-      static VALUE foo(VALUE self) { x(); y(); z(); }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0);
-      }
-    eof
-    foo = Registry.at('Foo#foo')
-    expect(foo.docstring).to eq 'DOCSTRING'
-  end
-
-  it "uses declaration comments as docstring if there are no others" do
-    parse <<-eof
-      static VALUE foo(VALUE self) { x(); y(); z(); }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        /* DOCSTRING */
-        rb_define_method(mFoo, "foo", foo, 0);
-        // DOCSTRING!
-        rb_define_method(mFoo, "bar", bar, 0);
-      }
-    eof
-    foo = Registry.at('Foo#foo')
-    expect(foo.docstring).to eq 'DOCSTRING'
-    bar = Registry.at('Foo#bar')
-    expect(bar.docstring).to eq 'DOCSTRING!'
-  end
-
-  it "looks for symbols in other file" do
-    other = <<-eof
-      /* DOCSTRING! */
-      static VALUE foo() { x(); }
-    eof
-    expect(File).to receive(:read).with('other.c').and_return(other)
-    parse <<-eof
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0); // in other.c
-      }
-    eof
-    foo = Registry.at('Foo#foo')
-    expect(foo.docstring).to eq 'DOCSTRING!'
-    expect(foo.file).to eq 'other.c'
-    expect(foo.line).to eq 2
-    expect(foo.source).to eq 'static VALUE foo() { x(); }'
-  end
-
-  it "allows extra file to include /'s and other filename characters" do
-    expect(File).to receive(:read).at_least(1).times.with('ext/a-file.c').and_return(<<-eof)
-      /* FOO */
-      VALUE foo(VALUE x) { int value = x; }
-
-      /* BAR */
-      VALUE bar(VALUE x) { int value = x; }
-    eof
-    parse_init <<-eof
-      rb_define_method(rb_cFoo, "foo", foo, 1); /* in ext/a-file.c */
-      rb_define_global_function("bar", bar, 1); /* in ext/a-file.c */
-    eof
-    expect(Registry.at('Foo#foo').docstring).to eq 'FOO'
-    expect(Registry.at('Kernel#bar').docstring).to eq 'BAR'
-  end
-
-  it "warns if other file can't be found" do
-    expect(log).to receive(:warn).with(/Missing source file `other.c' when parsing Foo#foo/)
-    parse <<-eof
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0); // in other.c
-      }
-    eof
-  end
-
-  it "looks at override comments for docstring" do
-    parse <<-eof
-      /* Document-method: Foo::foo
-       * Document-method: new
-       * Document-method: Foo::Bar#baz
-       * Foo bar!
-       */
-
-      // init comments
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0);
-        rb_define_method(mFoo, "initialize", foo, 0);
-        mBar = rb_define_module_under(mFoo, "Bar");
-        rb_define_method(mBar, "baz", foo, 0);
-      }
-    eof
-    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
-  end
-
-  it "looks at overrides in other files" do
-    other = <<-eof
-      /* Document-method: Foo::foo
-       * Document-method: new
-       * Document-method: Foo::Bar#baz
-       * Foo bar!
-       */
-    eof
-    expect(File).to receive(:read).with('foo/bar/other.c').and_return(other)
-    src = <<-eof
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo", foo, 0); // in foo/bar/other.c
-        rb_define_method(mFoo, "initialize", foo, 0); // in foo/bar/other.c
-        mBar = rb_define_module_under(mFoo, "Bar"); // in foo/bar/other.c
-        rb_define_method(mBar, "baz", foo, 0); // in foo/bar/other.c
-      }
-    eof
-    parse(src, 'foo/bar/baz/init.c')
-    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
-  end
-
-  it "adds return tag on methods ending in '?'" do
-    parse <<-eof
-      /* DOCSTRING */
-      static VALUE foo(VALUE self) { x(); y(); z(); }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo?", foo, 0);
-      }
-    eof
-    foo = Registry.at('Foo#foo?')
-    expect(foo.docstring).to eq 'DOCSTRING'
-    expect(foo.tag(:return).types).to eq ['Boolean']
-    expect(foo.tags(:return).size).to eq 1
-  end
-
-  it "does not add return tag if return tags exist" do
-    parse <<-eof
-      // @return [String] foo
-      static VALUE foo(VALUE self) { x(); y(); z(); }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "foo?", foo, 0);
-      }
-    eof
-    foo = Registry.at('Foo#foo?')
-    expect(foo.tag(:return).types).to eq ['String']
-    expect(foo.tags(:return).size).to eq 1
-  end
-
-  it "handles casted method names" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_method(mFoo, "bar", (METHOD)bar, 0);
-      rb_define_global_function("baz", (METHOD)baz, 0);
-    eof
-    expect(Registry.at('Foo#bar')).not_to be nil
-    expect(Registry.at('Kernel#baz')).not_to be nil
-  end
-
-  it "extracts at regular method parameters from C function signatures" do
-    parse <<-eof
-      static VALUE noargs_func(VALUE self) { return Qnil; }
-      static VALUE twoargs_func(VALUE self, VALUE a, VALUE b) { return a; }
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "noargs", noargs_func, 0);
-        rb_define_method(mFoo, "twoargs", twoargs_func, 2);
-      }
-    eof
-    expect(Registry.at('Foo#noargs').parameters).to be_empty
-    expect(Registry.at('Foo#twoargs').parameters).to eq [['a', nil], ['b', nil]]
-  end
-
-  it "extracts at varargs method parameters from C function signatures" do
-    parse <<-eof
-      static VALUE varargs_func(int argc, VALUE *argv, VALUE self) { return self; }
-      /* let's see if parser is robust in the face of strange spacing */
-      static VALUE varargs_func2(	int 	argc ,	VALUE
-	* 	 argv  ,VALUE  self	)
-
-      {return self;}
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_method(mFoo, "varargs", varargs_func, -1);
-        rb_define_method(	mFoo	,"varargs2",varargs_func2		,-1);
-      }
-    eof
-    expect(Registry.at('Foo#varargs').parameters).to eq [['*args', nil]]
-    expect(Registry.at('Foo#varargs2').parameters).to eq [['*args', nil]]
-  end
-
-  it "is not too strict or too loose about matching override comments to methods" do
-    parse <<-eof
-      /* Document-method: Foo::foo
-       * Document-method: new
-       * Document-method: Foo::Bar#baz
-       * Foo bar!
-       */
-
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        mBar = rb_define_module_under(mFoo, "Bar");
-
-        rb_define_method(mFoo, "foo", foo, 0);
-        rb_define_singleton_method(mFoo, "foo", foo, 0);
-        rb_define_method(mBar, "foo", foo, 0);
-        rb_define_singleton_method(mBar, "foo", foo, 0);
-
-        rb_define_method(mFoo, "initialize", foo, 0);
-        rb_define_method(mBar, "initialize", foo, 0);
-
-        rb_define_method(mFoo, "baz", foo, 0);
-        rb_define_singleton_method(mFoo, "baz", foo, 0);
-        rb_define_method(mBar, "baz", foo, 0);
-        rb_define_singleton_method(mBar, "baz", foo, 0);
-      }
-    eof
-    expect(Registry.at('Foo#foo').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo.foo').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo::Bar#foo').docstring).to be_empty
-    expect(Registry.at('Foo::Bar.foo').docstring).to be_empty
-    expect(Registry.at('Foo#initialize').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo::Bar#initialize').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo#baz').docstring).to be_empty
-    expect(Registry.at('Foo.baz').docstring).to be_empty
-    expect(Registry.at('Foo::Bar#baz').docstring).to eq 'Foo bar!'
-    expect(Registry.at('Foo::Bar.baz').docstring).to be_empty
-  end
-
-  it "recognizes core Ruby classes and modules provided by ruby.h" do
-    parse_init <<-eof
-      rb_define_method(rb_cFixnum, "popcount", fix_popcount, 0);
-      rb_define_private_method(rb_mKernel, "pp", obj_pp, 0);
-      rb_define_method(rb_mEnumerable, "to_hash", enum_to_hash, 0);
-    eof
-    expect(Registry.at('Fixnum').type).to eq :class
-    expect(Registry.at('Fixnum#popcount').type).to eq :method
-    expect(Registry.at('Object').type).to eq :class
-    # Methods defined on Kernel are treated as if they were defined on Object
-    expect(Registry.at('Object#pp').type).to eq :method
-    expect(Registry.at('Enumerable').type).to eq :module
-    expect(Registry.at('Enumerable#to_hash').type).to eq :method
-  end
-end

data/spec/handlers/c/mixin_handler_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::MixinHandler do
-  it "adds includes to modules or classes" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      cBar = rb_define_class("Bar", rb_cObject);
-      mBaz = rb_define_module("Baz");
-      rb_include_module(cBar, mFoo);
-      rb_include_module(mBaz, mFoo);
-    eof
-    foo = Registry.at('Foo')
-    bar = Registry.at('Bar')
-    baz = Registry.at('Baz')
-    expect(bar.mixins(:instance)).to eq [foo]
-    expect(baz.mixins(:instance)).to eq [foo]
-  end
-
-  it "adds include as proxy if symbol lookup fails" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_include_module(mFoo, mXYZ);
-    eof
-    foo = Registry.at('Foo')
-    expect(foo.mixins(:instance)).to eq [P('XYZ')]
-  end
-
-  it "fails if mixin variable cannot be detected" do
-    with_parser(:c) do
-      undoc_error <<-eof
-        void Init_Foo() {
-          VALUE noprefix;
-
-          mFoo = rb_define_module("Foo");
-          // YARD doesn't understand this
-          noprefix = rb_const_get(rb_cObject, rb_intern("Observable"));
-
-          rb_include_module(mFoo, noprefix);
-        }
-      eof
-    end
-  end
-end

data/spec/handlers/c/module_handler_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::ClassHandler do
-  it "registers modules" do
-    parse_init 'mFoo = rb_define_module("Foo");'
-    expect(Registry.at('Foo').type).to eq :module
-  end
-
-  it "registers classes under namespaces" do
-    parse_init <<-EOF
-      mBar = rb_define_module("Bar");
-      mFoo = rb_define_module_under(mBar, "Foo");
-    EOF
-    expect(Registry.at('Bar::Foo').type).to eq :module
-  end
-
-  it "remembers symbol defined with class" do
-    parse_init(<<-eof)
-      cXYZ = rb_define_module("Foo");
-      rb_define_method(cXYZ, "bar", bar, 0);
-    eof
-    expect(Registry.at('Foo').type).to eq :module
-    expect(Registry.at('Foo#bar')).not_to be nil
-  end
-
-  it "does not associate declaration comments as module docstring" do
-    parse_init(<<-eof)
-      /* Docstring! */
-      mFoo = rb_define_module("Foo");
-    eof
-    expect(Registry.at('Foo').docstring).to be_blank
-  end
-
-  it "associates a file with the declaration" do
-    parse_init(<<-eof)
-      mFoo = rb_define_module("Foo");
-    eof
-    expect(Registry.at('Foo').file).to eq '(stdin)'
-    expect(Registry.at('Foo').line).to eq 2
-  end
-
-  it "resolves namespace variable names across multiple files" do
-    parse_multi_file_init(
-      'mBar = rb_define_module_under(mFoo, "Bar");',
-      'mFoo = rb_define_module("Foo");'
-    )
-
-    expect(Registry.at('Foo::Bar').type).to eq :module
-  end
-
-  it "raises undoc error if a class is defined under a namespace that cannot be resolved" do
-    with_parser(:c) do
-      undoc_error <<-eof
-        void Init_Foo() {
-          mFoo = rb_define_class_under(invalid, "Foo", rb_cObject);
-        }
-      eof
-    end
-  end unless ENV['LEGACY']
-
-  it "raises undoc error if a module is defined under a namespace that cannot be resolved" do
-    with_parser(:c) do
-      undoc_error <<-eof
-        void Init_Foo() {
-          mFoo = rb_define_module_under(invalid, "Foo");
-        }
-      eof
-    end
-  end unless ENV['LEGACY']
-end

data/spec/handlers/c/override_comment_handler_spec.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::OverrideCommentHandler do
-  [:class, :module].each do |type|
-    it "handles Document-#{type}" do
-      parse(<<-eof)
-        void something;
-        /* Document-#{type}: A
-         * Foo bar baz
-         */
-        void
-      eof
-      expect(Registry.at('A').type).to eq type
-      expect(Registry.at('A').docstring).to eq 'Foo bar baz'
-      expect(Registry.at('A').file).to eq '(stdin)'
-      expect(Registry.at('A').line).to eq 2
-    end
-  end
-
-  it "handles multiple class/module combinations" do
-    parse(<<-eof)
-      /* Document-class: A
-       * Document-class: B
-       * Document-module: C
-       * Foo bar baz
-       */
-    eof
-    expect(Registry.at('A').docstring).to eq 'Foo bar baz'
-    expect(Registry.at('B').docstring).to eq 'Foo bar baz'
-    expect(Registry.at('C').docstring).to eq 'Foo bar baz'
-    expect(Registry.at('C').type).to eq :module
-  end
-
-  it "handles Document-class with inheritance" do
-    parse(<<-eof)
-      /* Document-class: A < B
-       * Foo bar baz
-       */
-      void
-    eof
-    obj = Registry.at('A')
-    expect(obj.type).to eq :class
-    expect(obj.docstring).to eq 'Foo bar baz'
-    expect(obj.superclass).to eq P('B')
-  end
-end

data/spec/handlers/c/path_handler_spec.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::PathHandler do
-  it "tracks variable names defined under namespaces" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
-      rb_define_method(cBar, "foo", foo, 1);
-    eof
-    expect(Registry.at('Foo::Bar')).not_to be nil
-    expect(Registry.at('Foo::Bar#foo')).not_to be nil
-  end
-
-  it "tracks variable names defined under namespaces" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
-      mBaz = rb_define_module_under(cBar, "Baz");
-      rb_define_method(mBaz, "foo", foo, 1);
-    eof
-    expect(Registry.at('Foo::Bar::Baz')).not_to be nil
-    expect(Registry.at('Foo::Bar::Baz#foo')).not_to be nil
-  end
-
-  it "handles rb_path2class() calls" do
-    parse_init <<-eof
-      somePath = rb_path2class("Foo::Bar::Baz")
-      mFoo = rb_define_module("Foo");
-      cBar = rb_define_class_under(mFoo, "Bar", rb_cObject);
-      mBaz = rb_define_module_under(cBar, "Baz");
-      rb_define_method(somePath, "foo", foo, 1);
-    eof
-    expect(Registry.at('Foo::Bar::Baz#foo')).not_to be nil
-  end
-end

data/spec/handlers/c/spec_helper.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-def parse(src, file = '(stdin)')
-  YARD::Registry.clear
-  parser = YARD::Parser::SourceParser.new(:c)
-  parser.file = file
-  parser.parse(StringIO.new(src))
-end
-
-def parse_init(src)
-  YARD::Registry.clear
-  YARD.parse_string("void Init_Foo() {\n#{src}\n}", :c)
-end
-
-def parse_multi_file_init(*srcs)
-  YARD::Registry.clear
-  srcs = srcs.map {|src| StringIO.new("void Init_Foo() {\n#{src}\n}") }
-  orig_type = YARD::Parser::SourceParser.parser_type
-  YARD::Parser::SourceParser.parser_type = :c
-  YARD::Parser::OrderedParser.new(OpenStruct.new, srcs).parse
-ensure
-  YARD::Parser::SourceParser.parser_type = orig_type
-end

data/spec/handlers/c/struct_handler_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe YARD::Handlers::C::StructHandler do
-  after { Registry.clear }
-
-  it "handles Struct class definitions" do
-    parse_init <<-eof
-      rb_cRange = rb_struct_define_without_accessor(
-          "Range", rb_cFoo, range_alloc,
-          "begin", "end", "excl", NULL);
-    eof
-    expect(Registry.at('Range').type).to eq :class
-    expect(Registry.at('Range').superclass).to eq P(:Foo)
-  end
-end

data/spec/handlers/class_condition_handler_spec.rb

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