yard 0.9.23 → 0.9.27

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

@@ -1,69 +0,0 @@
-class A
-  if some_condition
-    def a; end
-  elsif 1 == 1
-    def b; end
-  else
-    def c; end
-  end
-
-  def d; end if 50 * 2 == 101
-
-  unless false
-    def e; end
-  else
-    def enot; end
-  end
-
-  def g; end unless 5 * 2 == 101
-
-  def h
-    if 1
-      def hnot; end
-    end
-  end
-
-  if defined? A
-    def j; end
-  else
-    def jnot; end
-  end
-
-  if defined? RUBY_VERSION
-    def k; end
-  else
-    def knot; end
-  end
-
-  if 0
-    def nnot; end
-  else
-    def n; end
-  end
-
-  if 256
-    def o; end
-  else
-    def onot; end
-  end
-
-  if true
-    def p; end
-  else
-    def pnot; end
-  end
-
-  if false
-    def qnot; end
-  else
-    def q; end
-  end
-
-  private
-
-  if a == 1
-    def m; end
-  else
-    def mnot; end
-  end
-end

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

@@ -1,120 +0,0 @@
-# Docstring
-class A
-  module B; end
-  private
-  class B::C < String;
-    def method1; end
-    def method2; end
-  end
-  class X<B::C
-  end
-  class<<self
-    def classmethod1; end
-  end
-
-  class << A::B::C; def Hello; end end
-end
-
-module B
-  class A < A
-  end
-end
-
-class RT < XX::RT; end
-
-class Test1 < R "something"
-end
-
-class Test2 < R(/something/)
-end
-
-class Test3 < Struct.new(:foo, :bar)
-end
-
-class Test4 < OStruct.new
-end
-
-class Test5 < DelegateClass(Array)
-end
-
-class Test6 < NotDelegateClass(Array)
-end
-
-class ::MyRootClass
-end
-
-module Holder
-  module SomeMod
-    class Importer
-      def parse; end
-    end
-  end
-end
-
-module Holder
-  class Importer < Holder::SomeMod::Importer
-    def a; end
-  end
-end
-
-class String; end
-CONST = String
-class << CONST
-  def classmethod; end
-end
-
-module Q
-  class Logger < ::Logger; end
-  class Foo < ::Logger; end
-end
-
-class << Symbol
-  alias toString to_s
-end
-
-# Docstring
-class Zebra
-end
-
-# Docstring 2
-
-class Zebra
-end
-
-class Zebra
-end
-
-# A simple struct
-class RegularStruct < Struct; end
-class RegularStruct2 < ::Struct; end
-
-class Point < Struct.new(:x, :y, :z)
-end
-
-class AnotherPoint < Struct.new('XPoint', :a, :b, :c, :description)
-end
-
-# @attr [IO] input the input stream
-# @attr mode the mode to read
-# @attr [Proc, #call] someproc the proc to run
-class DoccedStruct < Struct.new(:input, :mode, :someproc)
-end
-
-# @attr [String] first the first entry
-# @attr_reader [Fixnum] second this only has a reader
-# @attr_writer [Array] third this only has a writer
-# @attr_reader [#read] fourth returns a proc that reads
-# @attr_writer [IO] fourth sets the proc that writes stuff
-class SemiDoccedStruct < Struct.new(:first, :second, :third, :fourth)
-end
-
-# @attr [String] first the first entry
-# @attr_reader [Fixnum] second this only has a reader
-# @attr_writer [Array] third this only has a writer
-# @attr_reader [#read] fourth returns a proc that reads
-# @attr_writer [IO] fourth sets the proc that writes stuff
-class NotAStruct; end
-
-class Outer1
-  class Inner1 < self; end
-end

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

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

@@ -1,29 +0,0 @@
-module ModName
-  private
-
-  # Docstring
-  module OtherModName
-  end
-end
-
-module            StressTest; end
-
-module A; end
-
-module Q
-	module A::B
-	end
-	module FOO; end
-end
-
-module ::Kernel
-  def x; end
-end
-
-module A; end
-module B; end
-module C; end
-class D; include A; include B; include C; end
-
-Z = Q
-module Z::FOO::A; end

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

@@ -1,8 +0,0 @@
-module A
-  Foo = 1
-  class B; end
-  module C; end
-  module D; end
-
-  private_constant :Foo, 'B', C
-end

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

@@ -1,11 +0,0 @@
-class A < NotHandler
-  process { hello }
-end
-
-class B < YARD::Handlers::Ruby::Base
-  process { test }
-end
-
-class C < YARD::Handlers::Ruby::Legacy::Base
-  process do test end
-end