yard 0.9.18 → 0.9.23

data/spec/handlers/c/alias_handler_spec.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::AliasHandler do
-  it "allows defining of aliases (rb_define_alias)" do
-    parse <<-eof
-      /* FOO */
-      VALUE foo(VALUE x) { int value = x; }
-      void Init_Foo() {
-        rb_cFoo = rb_define_class("Foo", rb_cObject);
-        rb_define_method(rb_cFoo, "foo", foo, 1);
-        rb_define_alias(rb_cFoo, "bar", "foo");
-      }
-    eof
-
-    expect(Registry.at('Foo#bar')).to be_is_alias
-    expect(Registry.at('Foo#bar').docstring).to eq 'FOO'
-  end
-
-  it "allows defining of aliases (rb_define_alias) of attributes" do
-    parse <<-eof
-      /* FOO */
-      VALUE foo(VALUE x) { int value = x; }
-      void Init_Foo() {
-        rb_cFoo = rb_define_class("Foo", rb_cObject);
-        rb_define_attr(rb_cFoo, "foo", 1, 0);
-        rb_define_alias(rb_cFoo, "foo?", "foo");
-      }
-    eof
-
-    expect(Registry.at('Foo#foo')).to be_reader
-    expect(Registry.at('Foo#foo?')).to be_is_alias
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + "/spec_helper"
+
+RSpec.describe YARD::Handlers::C::AliasHandler do
+  it "allows defining of aliases (rb_define_alias)" do
+    parse <<-eof
+      /* FOO */
+      VALUE foo(VALUE x) { int value = x; }
+      void Init_Foo() {
+        rb_cFoo = rb_define_class("Foo", rb_cObject);
+        rb_define_method(rb_cFoo, "foo", foo, 1);
+        rb_define_alias(rb_cFoo, "bar", "foo");
+      }
+    eof
+
+    expect(Registry.at('Foo#bar')).to be_is_alias
+    expect(Registry.at('Foo#bar').docstring).to eq 'FOO'
+  end
+
+  it "allows defining of aliases (rb_define_alias) of attributes" do
+    parse <<-eof
+      /* FOO */
+      VALUE foo(VALUE x) { int value = x; }
+      void Init_Foo() {
+        rb_cFoo = rb_define_class("Foo", rb_cObject);
+        rb_define_attr(rb_cFoo, "foo", 1, 0);
+        rb_define_alias(rb_cFoo, "foo?", "foo");
+      }
+    eof
+
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo?')).to be_is_alias
+  end
+end

data/spec/handlers/c/attribute_handler_spec.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::AttributeHandler do
-  def run(read, write, commented = nil)
-    parse <<-eof
-      /* FOO */
-      VALUE foo(VALUE x) { int value = x; }
-      void Init_Foo() {
-        rb_cFoo = rb_define_class("Foo", rb_cObject);
-        #{commented ? '/*' : ''}
-          rb_define_attr(rb_cFoo, "foo", #{read}, #{write});
-        #{commented ? '*/' : ''}
-      }
-    eof
-  end
-
-  it "handles readonly attribute (rb_define_attr)" do
-    run(1, 0)
-    expect(Registry.at('Foo#foo')).to be_reader
-    expect(Registry.at('Foo#foo=')).to be nil
-  end
-
-  it "handles writeonly attribute (rb_define_attr)" do
-    run(0, 1)
-    expect(Registry.at('Foo#foo')).to be nil
-    expect(Registry.at('Foo#foo=')).to be_writer
-  end
-
-  it "handles readwrite attribute (rb_define_attr)" do
-    run(1, 1)
-    expect(Registry.at('Foo#foo')).to be_reader
-    expect(Registry.at('Foo#foo=')).to be_writer
-  end
-
-  it "handles commented writeonly attribute (/* rb_define_attr */)" do
-    run(1, 1, true)
-    expect(Registry.at('Foo#foo')).to be_reader
-    expect(Registry.at('Foo#foo=')).to be_writer
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + "/spec_helper"
+
+RSpec.describe YARD::Handlers::C::AttributeHandler do
+  def run(read, write, commented = nil)
+    parse <<-eof
+      /* FOO */
+      VALUE foo(VALUE x) { int value = x; }
+      void Init_Foo() {
+        rb_cFoo = rb_define_class("Foo", rb_cObject);
+        #{commented ? '/*' : ''}
+          rb_define_attr(rb_cFoo, "foo", #{read}, #{write});
+        #{commented ? '*/' : ''}
+      }
+    eof
+  end
+
+  it "handles readonly attribute (rb_define_attr)" do
+    run(1, 0)
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be nil
+  end
+
+  it "handles writeonly attribute (rb_define_attr)" do
+    run(0, 1)
+    expect(Registry.at('Foo#foo')).to be nil
+    expect(Registry.at('Foo#foo=')).to be_writer
+  end
+
+  it "handles readwrite attribute (rb_define_attr)" do
+    run(1, 1)
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be_writer
+  end
+
+  it "handles commented writeonly attribute (/* rb_define_attr */)" do
+    run(1, 1, true)
+    expect(Registry.at('Foo#foo')).to be_reader
+    expect(Registry.at('Foo#foo=')).to be_writer
+  end
+end

data/spec/handlers/c/class_handler_spec.rb

@@ -1,78 +1,78 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + "/spec_helper"
-
-RSpec.describe YARD::Handlers::C::ClassHandler do
-  it "registers classes" do
-    parse_init 'cFoo = rb_define_class("Foo", rb_cObject);'
-    expect(Registry.at('Foo').type).to eq :class
-  end
-
-  it "registers classes under namespaces" do
-    parse_init <<-EOF
-      cBar = rb_define_class("Bar", rb_cObject);
-      cFoo = rb_define_class_under( cBar, "Foo", rb_cBaz );
-    EOF
-    expect(Registry.at('Bar::Foo').type).to eq :class
-    expect(Registry.at('Bar::Foo').superclass.path).to eq 'Baz'
-  end
-
-  it "remembers symbol defined with class" do
-    parse_init(<<-eof)
-      cXYZ = rb_define_class("Foo", rb_cObject);
-      rb_define_method(cXYZ, "bar", bar, 0);
-    eof
-    expect(Registry.at('Foo').type).to eq :class
-    expect(Registry.at('Foo#bar')).not_to be nil
-  end
-
-  it "looks up superclass symbol name" do
-    parse_init(<<-eof)
-      cXYZ = rb_define_class("Foo", rb_cObject);
-      cBar = rb_define_class("Bar", cXYZ);
-    eof
-    expect(Registry.at('Bar').superclass).to eq Registry.at('Foo')
-  end
-
-  it "uses superclass symbol name as proxy if not found" do
-    parse_init(<<-eof)
-      // cXYZ = rb_define_class("Foo", rb_cObject);
-      cBar = rb_define_class("Bar", cXYZ);
-    eof
-    expect(Registry.at('Bar').superclass).to eq P('XYZ')
-  end
-
-  it "does not associate declaration comments as class docstring" do
-    parse_init(<<-eof)
-      /* Docstring! */
-      cFoo = rb_define_class("Foo", cObject);
-    eof
-    expect(Registry.at('Foo').docstring).to be_blank
-  end
-
-  it "associates a file with the declaration" do
-    parse_init(<<-eof)
-      cFoo = rb_define_class("Foo", cObject);
-    eof
-    expect(Registry.at('Foo').file).to eq '(stdin)'
-    expect(Registry.at('Foo').line).to eq 2
-  end
-
-  it "properly handles Proxy superclasses" do
-    parse_init <<-eof
-      mFoo = rb_define_module("Foo");
-      cBar = rb_define_class_under(mFoo, "Bar", rb_cBar);
-    eof
-    expect(Registry.at('Foo::Bar').type).to eq :class
-    expect(Registry.at('Foo::Bar').superclass).to eq P('Bar')
-    expect(Registry.at('Foo::Bar').superclass.type).to eq :class
-  end
-
-  it "resolves namespace variable names across multiple files" do
-    parse_multi_file_init(
-      'cBar = rb_define_class_under(cFoo, "Bar", rb_cObject);',
-      'cFoo = rb_define_class("Foo", rb_cObject);'
-    )
-
-    expect(Registry.at('Foo::Bar').type).to eq :class
-  end
-end
+# frozen_string_literal: true
+require File.dirname(__FILE__) + "/spec_helper"
+
+RSpec.describe YARD::Handlers::C::ClassHandler do
+  it "registers classes" do
+    parse_init 'cFoo = rb_define_class("Foo", rb_cObject);'
+    expect(Registry.at('Foo').type).to eq :class
+  end
+
+  it "registers classes under namespaces" do
+    parse_init <<-EOF
+      cBar = rb_define_class("Bar", rb_cObject);
+      cFoo = rb_define_class_under( cBar, "Foo", rb_cBaz );
+    EOF
+    expect(Registry.at('Bar::Foo').type).to eq :class
+    expect(Registry.at('Bar::Foo').superclass.path).to eq 'Baz'
+  end
+
+  it "remembers symbol defined with class" do
+    parse_init(<<-eof)
+      cXYZ = rb_define_class("Foo", rb_cObject);
+      rb_define_method(cXYZ, "bar", bar, 0);
+    eof
+    expect(Registry.at('Foo').type).to eq :class
+    expect(Registry.at('Foo#bar')).not_to be nil
+  end
+
+  it "looks up superclass symbol name" do
+    parse_init(<<-eof)
+      cXYZ = rb_define_class("Foo", rb_cObject);
+      cBar = rb_define_class("Bar", cXYZ);
+    eof
+    expect(Registry.at('Bar').superclass).to eq Registry.at('Foo')
+  end
+
+  it "uses superclass symbol name as proxy if not found" do
+    parse_init(<<-eof)
+      // cXYZ = rb_define_class("Foo", rb_cObject);
+      cBar = rb_define_class("Bar", cXYZ);
+    eof
+    expect(Registry.at('Bar').superclass).to eq P('XYZ')
+  end
+
+  it "does not associate declaration comments as class docstring" do
+    parse_init(<<-eof)
+      /* Docstring! */
+      cFoo = rb_define_class("Foo", cObject);
+    eof
+    expect(Registry.at('Foo').docstring).to be_blank
+  end
+
+  it "associates a file with the declaration" do
+    parse_init(<<-eof)
+      cFoo = rb_define_class("Foo", cObject);
+    eof
+    expect(Registry.at('Foo').file).to eq '(stdin)'
+    expect(Registry.at('Foo').line).to eq 2
+  end
+
+  it "properly handles Proxy superclasses" do
+    parse_init <<-eof
+      mFoo = rb_define_module("Foo");
+      cBar = rb_define_class_under(mFoo, "Bar", rb_cBar);
+    eof
+    expect(Registry.at('Foo::Bar').type).to eq :class
+    expect(Registry.at('Foo::Bar').superclass).to eq P('Bar')
+    expect(Registry.at('Foo::Bar').superclass.type).to eq :class
+  end
+
+  it "resolves namespace variable names across multiple files" do
+    parse_multi_file_init(
+      'cBar = rb_define_class_under(cFoo, "Bar", rb_cObject);',
+      'cFoo = rb_define_class("Foo", rb_cObject);'
+    )
+
+    expect(Registry.at('Foo::Bar').type).to eq :class
+  end
+end

data/spec/handlers/c/constant_handler_spec.rb

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