yard 0.9.24 → 0.9.25

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

@@ -1,10 +0,0 @@
-module A
-  class B
-    @@somevar = "hello"
-	@@somevar.value = "H"
-
-    def method
-      @@somevar = "don't document this"
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-module A
-  class B
-	notaconstant = 2
-    SOMECONSTANT= "hello"
-
-    def method
-      SOMECONSTANT = "don't document this"
-    end
-
-    MYCONSTANT = A +
-      B +
-      C +
-      D
-  end
-end
-
-MyClass = Struct.new(:a, :b, :c)
-NotMyClass = Struct.new("NotMyClass2", :b, :c)
-MyEmptyStruct = Struct.new
-
-MyStructWithConstant = Struct.new do
-  # A constant.
-  CONSTANT = 42
-  # Special constant (empty symbol)
-  EMPTY = :''
-end
-
-# A crazy struct.
-#
-# @attr [String] bar An attr
-# @attr [Number] baz Another attr
-# @!attribute new_syntax
-#   Attribute defined with the new syntax
-#   @return [Symbol] something useful
-DocstringStruct = Struct.new(:bar, :baz, :new_syntax)

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

@@ -1,156 +0,0 @@
-class Foo
-  attr_accessor :ignoreme
-
-  # IMPLICIT METHOD!
-  # @return [String]
-  just_a_method_for :implicit0
-
-  # IMPLICIT METHOD2!
-  # @!scope class
-  just_a_method_for :implicit1
-
-  # IMPLICIT METHOD3!
-  # @!visibility protected
-  just_a_method_for :implicit2
-
-  # Not recognized
-  just_a_method_for :implicit_invalid
-
-  #
-  ## IS NOT RECOGNIZED!
-  just_a_method_for :implicit_invalid2
-
-  # @deprecated don't use this
-  just_a_method_for :implicit_invalid3
-
-  ##
-  # IS RECOGNIZED!
-  just_a_method_for 'implicit_valid'
-
-  # @!attribute [r]
-  # @return [Numeric] a number
-  a_readable_attribute :attr1
-
-  # @!attribute [w]
-  a_writable_attribute :attr2, 'bar'
-
-  # @!attribute
-  default_attribute :attr3
-
-  # @!attribute custom
-  default_attribute :attr4
-
-  # @!method xyz(a, b, c)
-  # The foo method
-  # @param [String] a
-  # @!visibility protected
-  # @!scope class
-  foo_bar
-
-  # @!macro property
-  #   @!method $1(${3-})
-  #   A $0 that is awesome.
-  #   @param $3 first parameter
-  #   @return [$2] the property $1
-  property :name, String, :a, :b, :c
-
-  # @!macro property
-  property :age, Fixnum, :value
-
-  # This is just for x
-  # @!macro [attach] parser
-  #   @!method $1(opts = {})
-  #   @return NOTHING!
-  parser :x
-
-  parser :c_parser
-
-  # Another docstring
-  parser :d_parser
-
-  # @!macro [attach] none
-  #   @!method none(foo, bar)
-  none
-
-  # @!macro something
-  #   @!method $1(a, b, c)
-  something :qux
-
-  # @!method qux2(a, b, c)
-  something
-
-  # @!method no_src
-
-  # @!macro
-  #   $1 $2 $3
-  def regular_meth(a, b, c) end
-
-  # @!macro [new] different
-  #   @!method $2_name(a = 1)
-
-  # @!macro different
-  implicit_with_different_method_name :wrong, :right
-
-  # @!scope module
-  a_module_function :modfunc1
-end
-
-module MyMixin
-  # @!macro [attach] special
-  #   DSL method $1
-  def defined_by_mixin; end
-end
-
-class Bar
-  parser :x_parser
-end
-
-class Baz < Foo
-  extend MyMixin
-  parser :y_parser
-  none { }
-  defined_by_mixin :mixin_method
-end
-
-# @!method my_other_method
-# Docstring for method
-method_that_makes_a_method
-
-# @!macro something
-foobarbaz :beep
-
-module DSLMethods
-  # @macro [attach] dsl_method
-  #   Returns $2 for $1
-  dsl_method :foo, String
-  dsl_method :bar, Integer
-end
-
-class AliasTest
-  class << self
-    # @!macro alias_main
-    #   @!method main_$1
-    #     Success main_$1
-    def main; end
-
-    # TODO: currently unsupported behavior
-    # @!macro alias_alt
-    #   @!method alias_$1
-    #     Success alias_$1
-    alias alt main
-
-    alias alt2 main
-  end
-
-  alt  :foo1
-  alt2 :foo2
-end
-
-class DirectiveMethods
-  # @!macro with_directive
-  #   @!parse
-  #     include $1
-  def self.attach(x) end
-
-  attach Bar
-end

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

@@ -1,59 +0,0 @@
-class Testing
-  # Ignore yields outside methods
-  raise NoMethodError, "reason"
-
-  # Should document this
-  def mymethod
-    raise ArgumentError, "Argument is missing"
-  end
-
-  # Don't document this
-  def mymethod2
-    raise(a)
-  end
-
-  # Don't document this (docstring takes precedence)
-  # @raise [A]
-  def mymethod3
-    raise SomethingElse
-  end
-
-  # Only document the first one (limitation of exc handler)
-  def mymethod4
-    raise(A)
-    raise B, "Argument", somethingelse
-  end
-
-  def mymethod5
-    raise YARD::Parser::UndocumentableError
-  end
-
-  def mymethod6
-    raise YARD::Handlers.constants("test")
-  end
-
-  def mymethod7
-    raise MethodCall('argument')
-  end
-
-  def mymethod8
-    raise ExceptionClass.new('blah')
-  end
-
-  def mymethod9
-    obj.raise IgnoreMe
-	obj.raise(IgnoreMe)
-  end
-
-  def mymethod10
-    raise ArgumentError 'Message' # actually a method call
-  end
-
-  def mymethod11
-    raise foo('bar')
-  end
-
-  def mymethod12
-    raise
-  end
-end

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

@@ -1,19 +0,0 @@
-module A; end
-module B
-  extend A
-end
-
-module C
-  extend self
-end
-
-module Q
-  module R
-    module S
-      extend A
-    end
-  end
-end
-
-module FromConstant; end
-FromConstant.extend A

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

@@ -1,10 +0,0 @@
-def a
-  if 1
-    # ignore this
-    def b; end
-  end
-
-  # don't ignore these even though we know they're not executed
-  def c; end if false
-  def d; end unless true
-end

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

@@ -1,128 +0,0 @@
-class Foo
-  class << self
-    def inherited; end
-    def included; end
-    # docstring
-    def extended; end
-    def method_added; end
-    def method_removed; end
-    def method_undefined; end
-  end
-
-  # A docstring but no return type
-  def initialize; end
-
-  def ==(other)
-    'hello'
-  end
-  def /(other) 'hi' end
-
-  attr_reader :method1
-
-  def method1
-    def dynamic; end
-  end
-
-  def self.method2; end
-
-  # Docstring
-  def String :: hello; "" end
-
-  def self.new() end
-
-  def [](key = 'default') puts key end
-  def []=(key, value) end
-  def
-allowed?
-end
-
-  def ` param; end
-  def /(x = File.new('x', 'w'), y = 2) end
-  def |; end; def =~ ()
-  def -@; end;
-  def d_splat(reg, **opts); end
-  def d_unnamed_splat(**); end
-end
-  def *(o) def +@; end
-    def ~@
-    end end
-  def &(o) end
-  def %(o) end
-  def ^(o) end
-
-  def optsmeth(x, opts = {}) end
-  def blockmeth(x, &block) end
-
-  # @param a [Fixnum]
-  # @overload def bar(a, b = 1)
-  #   @param a [String]
-  #   @return [String]
-  # @overload def baz(b, c)
-  #   @return [Fixnum]
-  # @overload bang(d, e)
-  def foo(*args); end
-
-  # No return tag
-  def boolean?; end
-
-  # @return without type
-  def boolean2?; end
-
-  # @return [NotBoolean, nil]
-  def boolean3?; end
-
-  # @overload rainy?
-  #   @return whether today is the rainy day.
-  def rainy?; end
-
-  attr_writer :attr_name
-  def attr_name; end
-
-  attr_reader :attr_name2
-  def attr_name2=; end
-
-  # @option opts :bar [String] It's bar!
-  def auto_opts(opts)
-  end
-end
-
-CONST = Foo
-def CONST.meth_on_const; end
-CONST2 = CONST
-def CONST2.meth2_on_const; end
-
-class D
-  alias b a
-
-  # foo bar
-  def a; end
-end
-
-class E
-  # @!macro prop
-  #   @!method $1(value)
-  #   $3
-  #   @return [$2]
-  def self.property(name, ret_type, docstring)
-  end
-
-  property :foo, String, "create a foo"
-
-  # @!macro xyz
-  #   @!method $1
-  def xyz; end
-
-  xyz :a
-end
-
-module F
-  class A
-    def foo; end
-
-    def end
-    end
-
-    # PASS
-    def bar; end
-  end
-end

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

@@ -1,40 +0,0 @@
-module A; end
-module B;
-  module C; end
-  module D; end
-end
-
-QQQ = B::D
-
-class X
-  include A
-  include B, B::C, NOTEXIST
-end
-
-module Y
-  include B::C, B if X == 2
-  include A
-  include QQQ
-
-  class << self; include A; end
-end
-
-module Z
-  include A, B
-end
-
-module ABC
-  module FOO; end
-  module DEF
-    module FOO
-      include ABC::FOO
-    end
-
-    module BAR
-      include ABC::BAR
-    end
-  end
-end
-
-module FromConstant; end
-FromConstant.include A