yard 0.9.18 → 0.9.19

data/spec/handlers/c/mixin_handler_spec.rb

@@ -1,44 +1,44 @@
-# 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
+# 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 +1,71 @@
-# 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
+# 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 +1,47 @@
-# 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
+# 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 +1,36 @@
-# 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
+# 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 +1,23 @@
-# 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
+# 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 +1,16 @@
-# 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
+# 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