yard 0.9.23 → 0.9.27

data/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -1,36 +0,0 @@
-class Testing
-  def pub; end
-
-  private
-
-  def priv; end
-  def notpriv; end
-  def notpriv2; end
-  def notpriv?; end
-
-  protected
-
-  def prot; end
-
-  public
-
-  def pub2; end
-
-  protected :notpriv, 'notpriv2', :notpriv?
-
-  private name
-  private *argument
-  private *(method_call)
-
-  def Foo; end
-  private :Foo
-
-  private def decpriv; end
-
-  private
-
-  class Bar; end
-  module Baz; end
-
-  private :not_exist!
-end

data/spec/handlers/examples/yield_handler_001.rb.txt

@@ -1,54 +0,0 @@
-class Testing
-  # Ignore yields outside methods
-  yield x, y, z
-
-  # Should document this
-  def mymethod
-    yield
-  end
-
-  # Has yield and yieldparam documentation
-  # @yield [a, b] Blah
-  # @yieldparam a Blah
-  # @yieldparam b Blah
-  def mymethod2
-    yield(b, a) # Yield something else
-  end
-
-  # Has yield documentation only
-  # @yield [a, b]
-  def mymethod3
-    yield self # Should not be changed
-  end
-
-  # Has yieldparam documentation only
-  # @yieldparam _self BLAH
-  def mymethod4
-    yield self
-  end
-
-  # Some weird possibilities..
-  # Document it all.
-
-
-  def mymethod5
-    yield :a, b, self, File.read('file', 'w'), CONSTANT if x == 2
-  end
-
-  def mymethod6
-    yield(b, a)
-  end
-
-  def mymethod7
-    yield a
-    yield b
-  end
-
-  def mymethod8
-    yield self
-  end
-
-  def mymethod9
-    yield super
-  end
-end

data/spec/handlers/exception_handler_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExceptionHandler" do
-  before(:all) { parse_file :exception_handler_001, __FILE__ }
-
-  it "does not document an exception outside of a method" do
-    expect(P('Testing').has_tag?(:raise)).to be false
-  end
-
-  it "documents a valid raise" do
-    expect(P('Testing#mymethod').tag(:raise).types).to eq ['ArgumentError']
-  end
-
-  it "only documents non-dynamic raises" do
-    expect(P('Testing#mymethod2').tag(:raise)).to be nil
-    expect(P('Testing#mymethod6').tag(:raise)).to be nil
-    expect(P('Testing#mymethod7').tag(:raise)).to be nil
-  end
-
-  it "treats ConstantName.new as a valid exception class" do
-    expect(P('Testing#mymethod8').tag(:raise).types).to eq ['ExceptionClass']
-  end
-
-  it "does not document a method with an existing @raise tag" do
-    expect(P('Testing#mymethod3').tag(:raise).types).to eq ['A']
-  end
-
-  it "only documents the first raise message of a method (limitation of exception handler)" do
-    expect(P('Testing#mymethod4').tag(:raise).types).to eq ['A']
-  end
-
-  it "handles complex class names" do
-    expect(P('Testing#mymethod5').tag(:raise).types).to eq ['YARD::Parser::UndocumentableError']
-  end
-
-  it "ignores any raise calls on a receiver" do
-    expect(P('Testing#mymethod9').tag(:raise)).to be nil
-  end
-
-  it "handles raise expressions that are method calls" do
-    expect(P('Testing#mymethod10').tag(:raise)).to be nil
-    expect(P('Testing#mymethod11').tag(:raise)).to be nil
-  end
-
-  it "ignores empty raise call" do
-    expect(P('Testing#mymethod12').tag(:raise)).to be nil
-  end
-end

data/spec/handlers/extend_handler_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ExtendHandler" do
-  before(:all) { parse_file :extend_handler_001, __FILE__ }
-
-  it "includes modules at class scope" do
-    expect(Registry.at(:B).class_mixins).to eq [P(:A)]
-    expect(Registry.at(:B).instance_mixins).to be_empty
-  end
-
-  it "handles a module extending itself" do
-    expect(Registry.at(:C).class_mixins).to eq [P(:C)]
-    expect(Registry.at(:C).instance_mixins).to be_empty
-  end
-
-  it "extends module with correct namespace" do
-    expect(Registry.at('Q::R::S').class_mixins.first.path).to eq 'A'
-  end
-
-  it "does not allow extending self if object is a class" do
-    undoc_error "class Foo; extend self; end"
-  end
-
-  it "adds mixins from extend calls to constants" do
-    expect(P('FromConstant').class_mixins).to eq [P('A')]
-  end
-end

data/spec/handlers/legacy_base_spec.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-include Parser::Ruby::Legacy
-
-RSpec.describe YARD::Handlers::Ruby::Legacy::Base, "#tokval" do
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
-
-  def tokval(code, *types)
-    @handler.send(:tokval, TokenList.new(code).first, *types)
-  end
-
-  it "returns the String's value without quotes" do
-    expect(tokval('"hello"')).to eq "hello"
-  end
-
-  it "does not allow interpolated strings with TkSTRING" do
-    expect(tokval('"#{c}"', RubyToken::TkSTRING)).to be nil
-  end
-
-  it "returns a Symbol's value as a String (as if it was done via :name.to_sym)" do
-    expect(tokval(':sym')).to eq :sym
-  end
-
-  it "returns nil for any non accepted type" do
-    expect(tokval('identifier')).to be nil
-    expect(tokval(':sym', RubyToken::TkId)).to be nil
-  end
-
-  it "accepts TkVal tokens by default" do
-    expect(tokval('2.5')).to eq 2.5
-    expect(tokval(':sym')).to eq :sym
-  end
-
-  it "accepts any ID type if TkId is set" do
-    expect(tokval('variable', RubyToken::TkId)).to eq "variable"
-    expect(tokval('CONSTANT', RubyToken::TkId)).to eq "CONSTANT"
-  end
-
-  it "allows extra token types to be accepted" do
-    expect(tokval('2.5', RubyToken::TkFLOAT)).to eq 2.5
-    expect(tokval('2', RubyToken::TkFLOAT)).to be nil
-    expect(tokval(':symbol', RubyToken::TkFLOAT)).to be nil
-  end
-
-  it "allows :string for any string type" do
-    expect(tokval('"hello"', :string)).to eq "hello"
-    expect(tokval('"#{c}"', :string)).to eq '#{c}'
-  end
-
-  it "does not include interpolated strings when using :attr" do
-    expect(tokval('"#{c}"', :attr)).to be nil
-  end
-
-  it "allows any number type with :number" do
-    expect(tokval('2.5', :number)).to eq 2.5
-    expect(tokval('2', :number)).to eq 2
-  end
-
-  it "allows method names with :identifier" do
-    expect(tokval('methodname?', :identifier)).to eq "methodname?"
-  end
-
-  # it "obeys documentation expectations" do docspec end
-end
-
-RSpec.describe YARD::Handlers::Base, "#tokval_list" do
-  before { @handler = Handlers::Ruby::Legacy::Base.new(nil, nil) }
-
-  def tokval_list(code, *types)
-    @handler.send(:tokval_list, TokenList.new(code), *types)
-  end
-
-  it "returns the list of tokvalues" do
-    expect(tokval_list(":a, :b, \"\#{c}\", 'd'", :attr)).to eq [:a, :b, 'd']
-    expect(tokval_list(":a, :b, File.read(\"\#{c}\", ['w']), :d",
-      RubyToken::Token)).to eq [:a, :b, 'File.read("#{c}", [\'w\'])', :d]
-  end
-
-  it "tries to skip any invalid tokens" do
-    expect(tokval_list(":a, :b, \"\#{c}\", :d", :attr)).to eq [:a, :b, :d]
-    expect(tokval_list(":a, :b, File.read(\"\#{c}\", 'w', File.open { }), :d", :attr)).to eq [:a, :b, :d]
-    expect(tokval_list("CONST1, identifier, File.read(\"\#{c}\", 'w', File.open { }), CONST2",
-      RubyToken::TkId)).to eq ['CONST1', 'identifier', 'CONST2']
-  end
-
-  it "ignores a token if another invalid token is read before a comma" do
-    expect(tokval_list(":a, :b XYZ, :c", RubyToken::TkSYMBOL)).to eq [:a, :c]
-  end
-
-  it "stops on most keywords" do
-    expect(tokval_list(':a rescue :x == 5', RubyToken::Token)).to eq [:a]
-  end
-
-  it "handles ignore parentheses that begin the token list" do
-    expect(tokval_list('(:a, :b, :c)', :attr)).to eq [:a, :b, :c]
-  end
-
-  it "ends when a closing parenthesis was found" do
-    expect(tokval_list(':a, :b, :c), :d', :attr)).to eq [:a, :b, :c]
-  end
-
-  it "ignores parentheses around items in a list" do
-    expect(tokval_list(':a, (:b), :c, (:d TEST), :e, [:f], :g', :attr)).to eq [:a, :b, :c, :e, :g]
-    expect(tokval_list(':a, (((:f)))', :attr)).to eq [:a, :f]
-    expect(tokval_list(':a, ([:f]), :c)', RubyToken::Token)).to eq [:a, '[:f]', :c]
-  end
-
-  it "does not stop on a true/false/self keyword (cannot handle nil)" do
-    expect(tokval_list(':a, true, :b, self, false, :c, nil, File, super, if, XYZ',
-      RubyToken::Token)).to eq [:a, true, :b, 'self', false, :c, 'File', 'super']
-  end
-
-  it "ignores invalid commas" do
-    expect(tokval_list(":a, :b, , :d")).to eq [:a, :b, :d]
-  end
-
-  it "returns an empty list if no matches were found" do
-    expect(tokval_list('attr_accessor :x')).to eq []
-  end
-
-  it "treats {} as a valid value" do
-    # FIXME: tokval_list destroys extra spaces surrounding the '=' in
-    #        this situation. This is technically a design flaw of the
-    #        tokval parser, but this is now the expected behaviour.
-    expect(tokval_list("opts = {}", :all)).to eq ["opts={}"]
-  end
-end

data/spec/handlers/method_condition_handler_spec.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodConditionHandler" do
-  before(:all) { parse_file :method_condition_handler_001, __FILE__ }
-
-  it "does not parse regular if blocks in methods" do
-    expect(Registry.at('#b')).to be nil
-  end
-
-  it "parses if/unless blocks in the form X if COND" do
-    expect(Registry.at('#c')).not_to be nil
-    expect(Registry.at('#d')).not_to be nil
-  end
-end

data/spec/handlers/method_handler_spec.rb

@@ -1,214 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MethodHandler" do
-  before(:all) do
-    log.enter_level(Logger::ERROR) do
-      parse_file :method_handler_001, __FILE__
-    end
-  end
-
-  it "adds methods to parent's #meths list" do
-    expect(P(:Foo).meths).to include(P("Foo#method1"))
-  end
-
-  it "parses and adds class methods (self.method2)" do
-    expect(P(:Foo).meths).to include(P("Foo.method2"))
-  end
-
-  it "parses and adds class methods from other namespaces (String.hello)" do
-    expect(P("String.hello")).to be_instance_of(CodeObjects::MethodObject)
-  end
-
-  [:[], :[]=, :allowed?, :/, :=~, :==, :`, :|, :*, :&, :%, :'^', :-@, :+@, :'~@'].each do |name|
-    it "allows valid method #{name}" do
-      expect(Registry.at("Foo##{name}")).not_to be nil
-    end
-  end
-
-  it "allows self.methname" do
-    expect(Registry.at("Foo.new")).not_to be nil
-  end
-
-  it "marks dynamic methods as such" do
-    expect(P('Foo#dynamic').dynamic?).to be true
-  end
-
-  it "shows that a method is explicitly defined (if it was originally defined implicitly by attribute)" do
-    expect(P('Foo#method1').is_explicit?).to be true
-  end
-
-  it "handles parameters" do
-    expect(P('Foo#[]').parameters).to eq [['key', "'default'"]]
-    expect(P('Foo#/').parameters).to eq [['x', "File.new('x', 'w')"], ['y', '2']]
-  end
-
-  it "handles multiline parameters" do
-    YARD.parse_string <<-EOF
-      class Bar
-        def multiline_params(x,
-          y, z, zz = 'zz',
-          *foo,
-          a: 'a', b: 'b',
-          c: 'c',
-          **bar,
-          &blk
-        )
-        end
-      end
-    EOF
-
-    sig = "def multiline_params(x, y, z, zz = 'zz', *foo, a: 'a', b: 'b', c: 'c', **bar, &blk)"
-    expect(P('Bar#multiline_params').signature).to eq sig
-  end if YARD.ruby2?
-
-  it "handles method signature with no parameters" do
-    YARD.parse_string "class Bar; def foo; end end"
-    expect(P('Bar#foo').signature).to eq 'def foo'
-  end
-
-  it "handles opts = {} as parameter" do
-    expect(P('Foo#optsmeth').parameters).to eq [['x', nil], ['opts', '{}']]
-  end
-
-  it "handles &block as parameter" do
-    expect(P('Foo#blockmeth').parameters).to eq [['x', nil], ['&block', nil]]
-  end
-
-  it "handles double splats" do
-    expect(P('Foo#d_splat').parameters).to eq [["reg", nil], ["**opts", nil]]
-    expect(P('Foo#d_unnamed_splat').parameters).to eq []
-  end
-
-  it "handles overloads" do
-    meth = P('Foo#foo')
-
-    o1 = meth.tags(:overload).first
-    expect(o1.name).to eq :bar
-    expect(o1.parameters).to eq [['a', nil], ['b', "1"]]
-    expect(o1.tag(:return).type).to eq "String"
-
-    o2 = meth.tags(:overload)[1]
-    expect(o2.name).to eq :baz
-    expect(o2.parameters).to eq [['b', nil], ['c', nil]]
-    expect(o2.tag(:return).type).to eq "Fixnum"
-
-    o3 = meth.tags(:overload)[2]
-    expect(o3.name).to eq :bang
-    expect(o3.parameters).to eq [['d', nil], ['e', nil]]
-    expect(o3.docstring).to be_empty
-    expect(o3.docstring).to be_blank
-  end
-
-  it "sets a return tag if not set on #initialize" do
-    meth = P('Foo#initialize')
-
-    expect(meth).to have_tag(:return)
-    expect(meth.tag(:return).types).to eq ["Foo"]
-    expect(meth.tag(:return).text).to eq "a new instance of Foo"
-  end
-
-  %w(inherited included method_added method_removed method_undefined).each do |meth|
-    it "sets @private tag on #{meth} callback method if no docstring is set" do
-      expect(P('Foo.' + meth)).to have_tag(:private)
-    end
-  end
-
-  it "does not set @private tag on extended callback method since docstring is set" do
-    expect(P('Foo.extended')).not_to have_tag(:private)
-  end
-
-  it "adds @return [Boolean] tag to methods ending in ? without return types" do
-    meth = P('Foo#boolean?')
-    expect(meth).to have_tag(:return)
-    expect(meth.tag(:return).types).to eq ['Boolean']
-  end
-
-  it "adds Boolean type to return tag without types" do
-    meth = P('Foo#boolean2?')
-    expect(meth).to have_tag(:return)
-    expect(meth.tag(:return).types).to eq ['Boolean']
-  end
-
-  it "does not change return type for method ending in ? with return types set" do
-    meth = P('Foo#boolean3?')
-    expect(meth).to have_tag(:return)
-    expect(meth.tag(:return).types).to eq ['NotBoolean', 'nil']
-  end
-
-  it "does not change return type for method ending in ? with return types set by @overload" do
-    meth = P('Foo#rainy?')
-    expect(meth).to have_tag(:overload)
-    expect(meth.tag(:overload)).to have_tag(:return)
-    expect(meth).not_to have_tag(:return)
-  end
-
-  it "adds method writer to existing attribute" do
-    expect(Registry.at('Foo#attr_name')).to be_reader
-    expect(Registry.at('Foo#attr_name=')).to be_writer
-  end
-
-  it "adds method reader to existing attribute" do
-    expect(Registry.at('Foo#attr_name2')).to be_reader
-    expect(Registry.at('Foo#attr_name2=')).to be_writer
-  end
-
-  it "generates an options parameter if @option refers to an undocumented parameter" do
-    meth = P('Foo#auto_opts')
-    expect(meth).to have_tag(:param)
-    expect(meth.tag(:param).name).to eq "opts"
-    expect(meth.tag(:param).types).to eq ["Hash"]
-  end
-
-  it "raises an undocumentable error when a method is defined on an object instance" do
-    undoc_error "error = Foo; def error.at(foo) end"
-    expect(Registry.at('error')).to be nil
-  end
-
-  it "allows class method to be defined on constant reference object" do
-    expect(Registry.at('Foo.meth_on_const')).not_to be nil
-    expect(Registry.at('Foo.meth2_on_const')).not_to be nil
-  end
-
-  it "copies alias information on method (re-)definition to new method" do
-    expect(Registry.at('D').aliases).to be_empty
-    expect(Registry.at('D#b').is_alias?).to be false
-    expect(Registry.at('D#a').is_alias?).to be false
-  end
-
-  it "adds macros for class methods" do
-    macro = CodeObjects::MacroObject.find('prop')
-    expect(macro).not_to be nil
-    expect(macro.macro_data).to eq "@!method $1(value)\n$3\n@return [$2]"
-    expect(macro.method_object).to eq Registry.at('E.property')
-    expect(macro).to be_attached
-    obj = Registry.at('E#foo')
-    expect(obj).not_to be nil
-    expect(obj.docstring).to eq 'create a foo'
-    expect(obj.signature).to eq 'def foo(value)'
-    expect(obj.tag(:return).types).to eq ['String']
-  end
-
-  it "handles macros on any object" do
-    macro = CodeObjects::MacroObject.find('xyz')
-    expect(macro).not_to be nil
-    expect(macro.macro_data).to eq '@!method $1'
-  end
-
-  it "skips macros on instance methods" do
-    expect(Registry.at('E#a')).to be nil
-  end
-
-  it "warns if the macro name is invalid" do
-    expect(log).to receive(:warn).with(/Invalid directive.*@!macro/)
-    YARD.parse_string "class Foo\n# @!macro\ndef self.foo; end\nend"
-  end
-
-  it "handles 'def end' methods" do
-    obj = Registry.at('F::A#foo')
-    expect(obj).not_to be nil
-    obj = Registry.at('F::A#bar')
-    expect(obj).not_to be nil
-    expect(obj.docstring).to eq 'PASS'
-  end
-end

data/spec/handlers/mixin_handler_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}MixinHandler" do
-  before(:all) { parse_file :mixin_handler_001, __FILE__ }
-
-  it "handles includes from classes or modules" do
-    expect(Registry.at(:X).instance_mixins).to include(P(:A))
-    expect(Registry.at(:Y).instance_mixins).to include(P(:A))
-  end
-
-  it "handles includes in class << self" do
-    expect(Registry.at(:Y).class_mixins).to include(P(:A))
-  end
-
-  it "handles includes for modules that don't yet exist" do
-    expect(Registry.at(:X).instance_mixins).to include(P(nil, :NOTEXIST))
-  end
-
-  it "sets the type of non-existing modules to :module" do
-    o = Registry.at(:X).instance_mixins.find {|obj| obj.name == :NOTEXIST }
-    expect(o.type).to eq :module
-  end
-
-  it "handles includes with multiple parameters" do
-    expect(Registry.at(:X)).not_to be nil
-  end
-
-  it "handles complex include statements" do
-    expect(P(:Y).instance_mixins).to include(P('B::C'))
-    expect(P(:Y).instance_mixins).to include(P(:B))
-  end
-
-  it "treats a mixed in Constant by taking its value as the real object name" do
-    expect(P(:Y).instance_mixins).to include(Registry.at('B::D'))
-  end
-
-  it "adds includes in the correct order when include is given multiple arguments" do
-    expect(P(:Z).instance_mixins).to eq [P(:A), P(:B)]
-  end
-
-  it "avoids including self for unresolved mixins of the same name" do
-    expect(P("ABC::DEF::FOO").mixins).to eq [P("ABC::FOO")]
-    expect(P("ABC::DEF::BAR").mixins).to eq [P("ABC::BAR")]
-  end
-
-  it "raises undocumentable error if argument is variable" do
-    undoc_error "module X; include invalid; end"
-    expect(Registry.at('X').mixins).to eq []
-  end
-
-  it "parses all other arguments before erroring out on undocumentable error" do
-    undoc_error "module X; include invalid, Y; end"
-    expect(Registry.at('X').mixins).to eq [P('Y')]
-  end
-
-  it "adds mixins from include calls to constants" do
-    expect(P('FromConstant').instance_mixins).to eq [P('A')]
-  end
-end

data/spec/handlers/module_function_handler_spec.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/spec_helper'
-
-RSpec.describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
-  after { Registry.clear }
-
-  def assert_module_function(namespace, name)
-    klass = Registry.at("#{namespace}.#{name}")
-    instance = Registry.at("#{namespace}##{name}")
-    expect(klass).not_to be nil
-    expect(instance).not_to be nil
-    expect(klass).to be_module_function
-    expect(instance).not_to be_module_function
-    expect(klass.visibility).to eq :public
-    expect(instance.visibility).to eq :private
-  end
-
-  it "is able to create a module function with parameters" do
-    YARD.parse_string <<-eof
-      module Foo
-        def bar; end
-        def baz; end
-
-        module_function :bar, :baz
-      end
-    eof
-    assert_module_function('Foo', 'bar')
-    assert_module_function('Foo', 'baz')
-  end
-
-  it "is able to set scope for duration of block without params" do
-    YARD.parse_string <<-eof
-      module Foo
-        def qux; end
-
-        module_function
-
-        def bar; end
-        def baz; end
-      end
-    eof
-    expect(Registry.at('Foo.qux')).to be nil
-    assert_module_function('Foo', 'bar')
-    assert_module_function('Foo', 'baz')
-  end
-
-  # @bug gh-563
-  it "copies tags to module function properly" do
-    YARD.parse_string <<-eof
-      module Foo
-        # @param [String] foo bar
-        # @option foo [String] bar (nil) baz
-        # @return [void]
-        def bar(foo); end
-        module_function :bar
-      end
-    eof
-    assert_module_function('Foo', 'bar')
-    o = Registry.at('Foo.bar')
-    expect(o.tag(:param).types).to eq ['String']
-    expect(o.tag(:param).name).to eq 'foo'
-    expect(o.tag(:param).text).to eq 'bar'
-    expect(o.tag(:option).name).to eq 'foo'
-    expect(o.tag(:option).pair.types).to eq ['String']
-    expect(o.tag(:option).pair.defaults).to eq ['nil']
-    expect(o.tag(:option).pair.text).to eq 'baz'
-    expect(o.tag(:return).types).to eq ['void']
-  end
-
-  it "handles all method names in parameters" do
-    YARD.parse_string <<-eof
-      module Foo
-        def -(t); end
-        def ==(other); end
-        def a?; end
-        module_function :-, '==', :a?
-      end
-    eof
-    assert_module_function('Foo', '-')
-    assert_module_function('Foo', '==')
-    assert_module_function('Foo', 'a?')
-  end
-
-  it "only accepts strings and symbols" do
-    YARD.parse_string <<-eof
-      module Foo
-        module_function name
-        module_function *argument
-        module_function *(method_call)
-      end
-    eof
-    expect(Registry.at('Foo#name')).to be nil
-    expect(Registry.at('Foo#argument')).to be nil
-    expect(Registry.at('Foo#method_call')).to be nil
-  end
-
-  it "handles constants passed in as symbols" do
-    YARD.parse_string <<-eof
-      module Foo
-        def Foo; end
-        module_function :Foo
-      end
-    eof
-    assert_module_function('Foo', 'Foo')
-  end
-end