yard 0.9.24 → 0.9.25

data/spec/handlers/attribute_handler_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}AttributeHandler" do
-  before(:all) { parse_file :attribute_handler_001, __FILE__ }
-
-  def read_write(namespace, name, read, write, scope = :instance)
-    rname = namespace.to_s + "#" + name.to_s
-    wname = namespace.to_s + "#" + name.to_s + "="
-    if read
-      expect(Registry.at(rname)).to be_instance_of(CodeObjects::MethodObject)
-    else
-      expect(Registry.at(rname)).to eq nil
-    end
-
-    if write
-      expect(Registry.at(wname)).to be_kind_of(CodeObjects::MethodObject)
-    else
-      expect(Registry.at(wname)).to eq nil
-    end
-
-    attrs = Registry.at(namespace).attributes[scope][name]
-    expect(attrs[:read]).to eq(read ? Registry.at(rname) : nil)
-    expect(attrs[:write]).to eq(write ? Registry.at(wname) : nil)
-  end
-
-  it "parses attributes inside modules too" do
-    expect(Registry.at("A#x=")).not_to eq nil
-  end
-
-  it "parses 'attr'" do
-    read_write(:B, :a, true, true)
-    read_write(:B, :a2, true, false)
-    read_write(:B, "a3", true, false)
-  end
-
-  it "parses 'attr_reader'" do
-    read_write(:B, :b, true, false)
-  end
-
-  it "parses 'attr_writer'" do
-    read_write(:B, :e, false, true)
-  end
-
-  it "parses 'attr_accessor'" do
-    read_write(:B, :f, true, true)
-  end
-
-  it "parses a list of attributes" do
-    read_write(:B, :b, true, false)
-    read_write(:B, :c, true, false)
-    read_write(:B, :d, true, false)
-  end
-
-  it "has a default docstring if one is not supplied" do
-    expect(Registry.at("B#f=").docstring).not_to be_empty
-  end
-
-  it "sets the correct docstring if one is supplied" do
-    expect(Registry.at("B#b").docstring).to eq "Docstring"
-    expect(Registry.at("B#c").docstring).to eq "Docstring"
-    expect(Registry.at("B#d").docstring).to eq "Docstring"
-  end
-
-  it "is able to differentiate between class and instance attributes" do
-    expect(P('B').class_attributes[:z][:read].scope).to eq :class
-    expect(P('B').instance_attributes[:z][:read].scope).to eq :instance
-  end
-
-  it "responds true in method's #is_attribute?" do
-    expect(P('B#a').is_attribute?).to be true
-    expect(P('B#a=').is_attribute?).to be true
-  end
-
-  it "does not return true for #is_explicit? in created methods" do
-    Registry.at(:B).meths.each do |meth|
-      expect(meth.is_explicit?).to be false
-    end
-  end
-
-  it "handles attr call with no arguments" do
-    expect { StubbedSourceParser.parse_string "attr" }.not_to raise_error
-  end
-
-  it "adds existing reader method as part of attr_writer combo" do
-    expect(Registry.at('C#foo=').attr_info[:read]).to eq Registry.at('C#foo')
-  end
-
-  it "adds existing writer method as part of attr_reader combo" do
-    expect(Registry.at('C#foo').attr_info[:write]).to eq Registry.at('C#foo=')
-  end
-
-  it "maintains visibility for attr_reader" do
-    expect(Registry.at('D#parser').visibility).to eq :protected
-  end
-end

data/spec/handlers/base_spec.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-require 'ostruct'
-
-include Parser
-
-RSpec.describe YARD::Handlers::Base do
-  describe "#handles and inheritance" do
-    before do
-      allow(Handlers::Base).to receive(:inherited)
-    end
-
-    it "keeps track of subclasses" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler < Handlers::Base; end
-    end
-
-    it "raises NotImplementedError if process is called on a class with no #process" do
-      class TestNotImplementedHandler < Handlers::Base
-      end
-
-      expect { TestNotImplementedHandler.new(0, 0).process }.to raise_error(NotImplementedError)
-    end
-
-    it "allows multiple handles arguments" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler1 < Handlers::Base
-        handles :a, :b, :c
-      end
-      expect(TestHandler1.handlers).to eq [:a, :b, :c]
-    end
-
-    it "allows multiple handles calls" do
-      expect(Handlers::Base).to receive(:inherited).once
-      class TestHandler2 < Handlers::Base
-        handles :a
-        handles :b
-        handles :c
-      end
-      expect(TestHandler2.handlers).to eq [:a, :b, :c]
-    end
-  end
-
-  describe "#abort! (and HandlerAborted)" do
-    it "allows HandlerAborted to be raised" do
-      class AbortHandler1 < Handlers::Ruby::Base
-        process { abort! }
-      end
-      expect { AbortHandler1.new(nil, nil).process }.to raise_error(HandlerAborted)
-    end
-  end
-
-  describe "transitive tags" do
-    it "adds transitive tags to children" do
-      Registry.clear
-      YARD.parse_string <<-eof
-        # @since 1.0
-        # @author Foo
-        class A
-          def foo; end
-          # @since 1.1
-          def bar; end
-        end
-      eof
-      expect(Registry.at('A').tag(:since).text).to eq "1.0"
-      expect(Registry.at('A#foo').tag(:since).text).to eq "1.0"
-      expect(Registry.at('A#bar').tag(:since).text).to eq "1.1"
-      expect(Registry.at('A#bar').tag(:author)).to be nil
-    end
-  end
-
-  describe "sharing global state" do
-    it "allows globals to share global state among handlers" do
-      class GlobalStateHandler1 < Handlers::Ruby::Base
-        class << self; attr_accessor :state end
-        handles :class
-        process { self.class.state = globals.foo; globals.foo = :bar }
-      end
-
-      class GlobalStateHandler2 < Handlers::Ruby::Base
-        class << self; attr_accessor :state end
-        handles :def
-        process { self.class.state = globals.foo }
-      end
-
-      2.times do
-        YARD.parse_string 'class Foo; end; def foo; end'
-        expect(GlobalStateHandler1.state).to eq nil
-        expect(GlobalStateHandler2.state).to eq :bar
-      end
-    end
-  end if HAVE_RIPPER
-
-  describe "#push_state" do
-    def process(klass)
-      state = OpenStruct.new(:namespace => "ROOT", :scope => :instance, :owner => "ROOT")
-      klass.new(state, nil).process
-    end
-
-    it "pushes and return all old state info after block" do
-      class PushStateHandler1 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:namespace => "FOO", :scope => :class, :owner => "BAR") do
-            expect(namespace).to eq "FOO"
-            expect(scope).to eq :class
-            expect(owner).to eq "BAR"
-          end
-          expect(namespace).to eq "ROOT"
-          expect(owner).to eq "ROOT"
-          expect(scope).to eq :instance
-        end
-      end
-      process PushStateHandler1
-    end
-
-    it "allows owner to be pushed individually" do
-      class PushStateHandler2 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:owner => "BAR") do
-            expect(namespace).to eq "ROOT"
-            expect(scope).to eq :instance
-            expect(owner).to eq "BAR"
-          end
-          expect(owner).to eq "ROOT"
-        end
-      end
-      process PushStateHandler2
-    end
-
-    it "allows scope to be pushed individually" do
-      class PushStateHandler3 < Handlers::Base
-        include RSpec::Matchers
-        RSpec::Expectations::Syntax.enable_expect(self)
-
-        def process
-          push_state(:scope => :foo) do
-            expect(namespace).to eq "ROOT"
-            expect(scope).to eq :foo
-            expect(owner).to eq "ROOT"
-          end
-          expect(scope).to eq :instance
-        end
-      end
-      process PushStateHandler3
-    end
-  end
-
-  describe ".in_file" do
-    def parse(filename, parser_type, src = "class A; end")
-      parser = Parser::SourceParser.new(parser_type)
-      parser.instance_variable_set("@file", filename)
-      parser.parse(StringIO.new(src))
-    end
-
-    def create_handler(stmts, parser_type)
-      $handler_counter ||= 0
-      sklass = parser_type == :ruby ? "Base" : "Legacy::Base"
-      instance_eval(<<-eof, __FILE__, __LINE__ + 1)
-        class ::InFileHandler#{$handler_counter += 1} < Handlers::Ruby::#{sklass}
-          handles(/^class/)
-          #{stmts}
-          def process; MethodObject.new(:root, :FOO) end
-        end
-      eof
-    end
-
-    def test_handler(file, stmts, creates = true, parser_type = :ruby)
-      Registry.clear
-      expect(Registry.at('#FOO')).to be nil
-      create_handler(stmts, parser_type)
-      parse(file, parser_type)
-      expect(Registry.at('#FOO')).send(creates ? :not_to : :to, be_nil)
-      Handlers::Base.subclasses.delete_if {|k, _v| k.to_s =~ /^InFileHandler/ }
-    end
-
-    [:ruby, :ruby18].each do |parser_type|
-      next if parser_type == :ruby && LEGACY_PARSER
-      describe "Parser type = #{parser_type.inspect}" do
-        it "allows handler to be specific to a file" do
-          test_handler 'file_a.rb', 'in_file "file_a.rb"', true, parser_type
-        end
-
-        it "ignores handler if filename does not match" do
-          test_handler 'file_b.rb', 'in_file "file_a.rb"', false, parser_type
-        end
-
-        it "only tests filename part when given a String" do
-          test_handler '/path/to/file_a.rb', 'in_file "/to/file_a.rb"', false, parser_type
-        end
-
-        it "tests exact match for entire String" do
-          test_handler 'file_a.rb', 'in_file "file"', false, parser_type
-        end
-
-        it "allows a Regexp as argument and test against full path" do
-          test_handler 'file_a.rbx', 'in_file(/\.rbx$/)', true, parser_type
-          test_handler '/path/to/file_a.rbx', 'in_file(/\/to\/file_/)', true, parser_type
-          test_handler '/path/to/file_a.rbx', 'in_file(/^\/path/)', true, parser_type
-        end
-
-        it "allows multiple in_file declarations" do
-          stmts = 'in_file "x"; in_file(/y/); in_file "foo.rb"'
-          test_handler 'foo.rb', stmts, true, parser_type
-          test_handler 'xyzzy.rb', stmts, true, parser_type
-          test_handler 'x', stmts, true, parser_type
-        end
-      end
-    end
-  end
-end

data/spec/handlers/c/alias_handler_spec.rb

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