yard 0.9.21 → 0.9.26

data/spec/handlers/c/constant_handler_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::ConstantHandler do
-  it "registers constants" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_const(mFoo, "FOO", ID2SYM(100));
-      rb_define_global_const("BAR", ID2SYM(100));
-    eof
-    expect(Registry.at('Foo::FOO').type).to eq :constant
-    expect(Registry.at('BAR').type).to eq :constant
-  end
-
-  it "looks for override comments" do
-    parse <<-eof
-      /* Document-const: FOO
-       * Document-const: Foo::BAR
-       * Foo bar!
-       */
-
-      void Init_Foo() {
-        mFoo = rb_define_module("Foo");
-        rb_define_const(mFoo, "FOO", ID2SYM(100));
-        rb_define_const(mFoo, "BAR", ID2SYM(101));
-      }
-    eof
-    foo = Registry.at('Foo::FOO')
-    expect(foo.type).to eq :constant
-    expect(foo.docstring).to eq 'Foo bar!'
-    expect(foo.value).to eq 'ID2SYM(100)'
-    expect(foo.file).to eq '(stdin)'
-    expect(foo.line).to eq 8
-    bar = Registry.at('Foo::BAR')
-    expect(bar.type).to eq :constant
-    expect(bar.docstring).to eq 'Foo bar!'
-    expect(bar.file).to eq '(stdin)'
-    expect(bar.line).to eq 9
-    expect(bar.value).to eq 'ID2SYM(101)'
-  end
-
-  it "uses comment attached to declaration as fallback" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_const(mFoo, "FOO", ID2SYM(100)); // foobar!
-    eof
-    foo = Registry.at('Foo::FOO')
-    expect(foo.value).to eq 'ID2SYM(100)'
-    expect(foo.docstring).to eq 'foobar!'
-  end
-
-  it "allows the form VALUE: DOCSTRING to document value" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_const(mFoo, "FOO", ID2SYM(100)); // 100: foobar!
-    eof
-    foo = Registry.at('Foo::FOO')
-    expect(foo.value).to eq '100'
-    expect(foo.docstring).to eq 'foobar!'
-  end
-
-  it "allows escaping of backslashes in VALUE: DOCSTRING syntax" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      rb_define_const(mFoo, "FOO", ID2SYM(100)); // 100\\:x\\:y: foobar:x!
-    eof
-    foo = Registry.at('Foo::FOO')
-    expect(foo.value).to eq '100:x:y'
-    expect(foo.docstring).to eq 'foobar:x!'
-  end
-end

data/spec/handlers/c/init_handler_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::InitHandler do
-  it "adds documentation in Init_ClassName() to ClassName" do
-    parse(<<-eof)
-      // Bar!
-      void Init_A() {
-        rb_cA = rb_define_class("A", rb_cObject);
-      }
-    eof
-    expect(Registry.at('A').docstring).to eq 'Bar!'
-  end
-
-  it "does not add documentation if ClassName is not created in Init" do
-    parse(<<-eof)
-      // Bar!
-      void Init_A() {
-      }
-    eof
-    expect(Registry.at('A')).to be nil
-  end
-
-  it "does not overwrite override comment" do
-    parse(<<-eof)
-      /* Document-class: A
-       * Foo!
-       */
-
-      // Bar!
-      static SWIGEXPORT void Init_A() {
-        rb_cA = rb_define_class("A", rb_cObject);
-      }
-    eof
-    expect(Registry.at('A').docstring).to eq 'Foo!'
-  end
-
-  it "checks non-Init methods for declarations too" do
-    parse(<<-eof)
-      void foo(int x, int y, char *name) {
-        rb_cB = rb_define_class("B", rb_cObject);
-        rb_define_method(rb_cB, "foo", foo_impl, 0);
-      }
-    eof
-    expect(Registry.at('B')).to be_a(CodeObjects::ClassObject)
-    expect(Registry.at('B#foo')).to be_a(CodeObjects::MethodObject)
-  end
-end

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