yard 0.9.24 → 0.9.25

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

data/spec/handlers/class_handler_spec.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ClassHandler" do
-  before(:all) { parse_file :class_handler_001, __FILE__ }
-
-  it "parses a class block with docstring" do
-    expect(P("A").docstring).to eq "Docstring"
-  end
-
-  it "handles complex class names" do
-    expect(P("A::B::C")).not_to eq nil
-  end
-
-  it "handles the subclassing syntax" do
-    expect(P("A::B::C").superclass).to eq P(:String)
-    expect(P("A::X").superclass).to eq Registry.at("A::B::C")
-  end
-
-  it "interprets class << self as a class level block" do
-    expect(P("A.classmethod1")).not_to eq nil
-  end
-
-  it "interprets class << ClassName as a class level block in ClassName's namespace" do
-    expect(P("A::B::C.Hello")).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  it "makes visibility public when parsing a block" do
-    expect(P("A::B::C#method1").visibility).to eq :public
-  end
-
-  it "sets superclass type to :class if it is a Proxy" do
-    expect(P("A::B::C").superclass.type).to eq :class
-  end
-
-  it "looks for a superclass before creating the class if it shares the same name" do
-    expect(P('B::A').superclass).to eq P('A')
-  end
-
-  it "handles class definitions in the form ::ClassName" do
-    expect(Registry.at("MyRootClass")).not_to be nil
-  end
-
-  it "handles superclass as a constant-style method (camping style < R /path/)" do
-    expect(P('Test1').superclass).to eq P(:R)
-    expect(P('Test2').superclass).to eq P(:R)
-    expect(P('Test6').superclass).to eq P(:NotDelegateClass)
-  end
-
-  it "handles superclass with OStruct.new or Struct.new syntax (superclass should be OStruct/Struct)" do
-    expect(P('Test3').superclass).to eq P(:Struct)
-    expect(P('Test4').superclass).to eq P(:OStruct)
-  end
-
-  it "handles DelegateClass(CLASSNAME) superclass syntax" do
-    expect(P('Test5').superclass).to eq P(:Array)
-  end
-
-  it "handles a superclass of the same name in the form ::ClassName" do
-    expect(P('Q::Logger').superclass).to eq P(:Logger)
-    expect(P('Q::Foo').superclass).not_to eq P('Q::Logger')
-  end
-
-  ["CallMethod('test')", "VSD^#}}", 'not.aclass', 'self'].each do |klass|
-    it "raises an UndocumentableError for invalid class '#{klass}'" do
-      with_parser(:ruby18) { undoc_error "class #{klass}; end" }
-    end
-  end
-
-  ['@@INVALID', 'hi', '$MYCLASS', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError for invalid superclass '#{klass}' but it should create the class." do
-      expect(YARD::CodeObjects::ClassObject).to receive(:new).with(Registry.root, 'A')
-      with_parser(:ruby18) { undoc_error "class A < #{klass}; end" }
-      expect(Registry.at('A').superclass).to eq P(:Object)
-    end
-  end
-
-  ['not.aclass', 'self', 'AnotherClass.new'].each do |klass|
-    it "raises an UndocumentableError if the constant class reference 'class << SomeConstant' does not point to a valid class name" do
-      with_parser(:ruby18) do
-        undoc_error <<-eof
-          CONST = #{klass}
-          class << CONST; end
-        eof
-      end
-      expect(Registry.at(klass)).to be nil
-    end
-  end
-
-  it "documents 'class << SomeConstant' by using SomeConstant's value as a reference to the real class name" do
-    expect(Registry.at('String.classmethod')).not_to be nil
-  end
-
-  it "allows class << SomeRubyClass to create the class if it does not exist" do
-    expect(Registry.at('Symbol.toString')).not_to be nil
-  end
-
-  it "documents 'class Exception' without running into superclass issues" do
-    Parser::SourceParser.parse_string <<-eof
-      class Exception
-      end
-    eof
-    expect(Registry.at(:Exception)).not_to be nil
-  end
-
-  it "documents 'class RT < XX::RT' with proper superclass even if XX::RT is a proxy" do
-    expect(Registry.at(:RT)).not_to be nil
-    expect(Registry.at(:RT).superclass).to eq P('XX::RT')
-  end
-
-  it "does not overwrite docstring with an empty one" do
-    expect(Registry.at(:Zebra).docstring).to eq "Docstring 2"
-  end
-
-  it "turns 'class Const < Struct.new(:sym)' into class Const with attr :sym" do
-    obj = Registry.at("Point")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:x, :y, :z].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "turns 'class Const < Struct.new('Name', :sym)' into class Const with attr :sym" do
-    obj = Registry.at("AnotherPoint")
-    expect(obj).to be_kind_of(CodeObjects::ClassObject)
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-
-    expect(Registry.at("XPoint")).to be nil
-  end
-
-  it "creates a Struct::Name class when class Const < Struct.new('Name', :sym) is found" do
-    obj = Registry.at("Struct::XPoint")
-    expect(obj).not_to be nil
-  end
-
-  it "attaches attribtues to the generated Struct::Name class when Struct.new('Name') is used" do
-    obj = Registry.at("Struct::XPoint")
-    attrs = obj.attributes[:instance]
-    [:a, :b, :c].each do |key|
-      expect(attrs).to have_key(key)
-      expect(attrs[key][:read]).not_to be nil
-      expect(attrs[key][:write]).not_to be nil
-    end
-  end
-
-  it "uses @attr to set attribute descriptions on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#input")
-    expect(obj.docstring).to eq "the input stream"
-  end
-
-  it "uses @attr to set attribute types on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#someproc")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Proc", "#call"]
-  end
-
-  it "defaults types unspecified by @attr to Object on Struct subclasses" do
-    obj = Registry.at("DoccedStruct#mode")
-    expect(obj).not_to be nil
-    expect(obj.tag(:return)).not_to be nil
-    expect(obj.tag(:return).types).to eq ["Object"]
-  end
-
-  it "creates parameters for writers of Struct subclass's attributes" do
-    obj = Registry.at("DoccedStruct#input=")
-    expect(obj.tags(:param).size).to eq 1
-    expect(obj.tag(:param).types).to eq ["IO"]
-  end
-
-  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
-    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
-      it "defines both readers and writers when @attr is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:first][:read]).not_to be nil
-        expect(attrs[:first][:write]).not_to be nil
-      end
-
-      it "defines only a reader when only @attr_reader is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:second][:read]).not_to be nil
-        expect(attrs[:second][:write]).to be nil
-      end
-
-      it "defines only a writer when only @attr_writer is used on Structs" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:third][:read]).to be nil
-        expect(attrs[:third][:write]).not_to be nil
-      end
-
-      it "defines a reader with correct return types when @attr_reader is used on Structs" do
-        obj = Registry.at("#{struct}#second")
-        expect(obj.tag(:return).types).to eq ["Fixnum"]
-      end
-
-      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
-        obj = Registry.at("#{struct}#third=")
-        expect(obj.tag(:param).types).to eq ["Array"]
-      end
-
-      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
-        obj = Registry.at(struct)
-        attrs = obj.attributes[:instance]
-        expect(attrs[:fourth][:read]).not_to be nil
-        expect(attrs[:fourth][:write]).not_to be nil
-      end
-
-      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth")
-        expect(obj.tag(:return).types).to eq ["#read"]
-      end
-
-      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
-        obj = Registry.at("#{struct}#fourth=")
-        expect(obj.tag(:param).types).to eq ["IO"]
-      end
-
-      it "extracts text from @attr_reader" do
-        expect(Registry.at("#{struct}#fourth").docstring).to eq "returns a proc that reads"
-      end
-
-      it "extracts text from @attr_writer" do
-        expect(Registry.at("#{struct}#fourth=").docstring).to eq "sets the proc that writes stuff"
-      end
-    end
-  end
-
-  it "inherits from a regular struct" do
-    expect(Registry.at('RegularStruct').superclass).to eq P(:Struct)
-    expect(Registry.at('RegularStruct2').superclass).to eq P(:Struct)
-  end
-
-  it "handles inheritance from 'self'" do
-    expect(Registry.at('Outer1::Inner1').superclass).to eq Registry.at('Outer1')
-  end
-end