sord 0.7.1 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -17,8 +17,12 @@ class Array
17
17
 
18
18
  def collect!(); end
19
19
 
20
+ def difference(*_); end
21
+
20
22
  def dig(*_); end
21
23
 
24
+ def filter!(); end
25
+
22
26
  def flatten!(*_); end
23
27
 
24
28
  def pack(*_); end
@@ -30,6 +34,8 @@ class Array
30
34
  def shelljoin(); end
31
35
 
32
36
  def to_h(); end
37
+
38
+ def union(*_); end
33
39
  end
34
40
 
35
41
  class Array
@@ -43,10 +49,6 @@ class BasicObject
43
49
  extend ::T::Sig
44
50
  end
45
51
 
46
- class BasicSocket
47
- def read_nonblock(len, str=T.unsafe(nil), exception: T.unsafe(nil)); end
48
- end
49
-
50
52
  class BasicSocket
51
53
  extend ::T::Sig
52
54
  end
@@ -69,13 +71,13 @@ class BigDecimal
69
71
 
70
72
  def self.mode(*_); end
71
73
 
74
+ def self.new(*args, **kwargs); end
75
+
72
76
  def self.save_exception_mode(); end
73
77
 
74
78
  def self.save_limit(); end
75
79
 
76
80
  def self.save_rounding_mode(); end
77
-
78
- def self.ver(); end
79
81
  end
80
82
 
81
83
  module BigMath
@@ -94,6 +96,8 @@ class Binding
94
96
  def local_variable_set(_, _1); end
95
97
 
96
98
  def receiver(); end
99
+
100
+ def source_location(); end
97
101
  end
98
102
 
99
103
  class Binding
@@ -519,20 +523,6 @@ class Bundler::Installer
519
523
  def self.install(root, definition, options=T.unsafe(nil)); end
520
524
  end
521
525
 
522
- class Bundler::LockfileGenerator
523
- def definition(); end
524
-
525
- def generate!(); end
526
-
527
- def initialize(definition); end
528
-
529
- def out(); end
530
- end
531
-
532
- class Bundler::LockfileGenerator
533
- def self.generate(definition); end
534
- end
535
-
536
526
  module Bundler::MatchPlatform
537
527
  extend ::T::Sig
538
528
  end
@@ -807,7 +797,7 @@ class Bundler::Settings::Mirror
807
797
  end
808
798
 
809
799
  class Bundler::Settings::Mirrors
810
- def each(); end
800
+ def each(&blk); end
811
801
 
812
802
  def for(uri); end
813
803
 
@@ -1059,6 +1049,18 @@ class ClosedQueueError
1059
1049
  extend ::T::Sig
1060
1050
  end
1061
1051
 
1052
+ module Colorize::ClassMethods
1053
+ extend ::T::Sig
1054
+ end
1055
+
1056
+ module Colorize::InstanceMethods
1057
+ extend ::T::Sig
1058
+ end
1059
+
1060
+ module Colorize
1061
+ extend ::T::Sig
1062
+ end
1063
+
1062
1064
  module Comparable
1063
1065
  extend ::T::Sig
1064
1066
  end
@@ -1074,10 +1076,36 @@ end
1074
1076
 
1075
1077
  ConditionVariable = Thread::ConditionVariable
1076
1078
 
1079
+ module Coverage
1080
+ extend ::T::Sig
1081
+ def self.line_stub(file); end
1082
+
1083
+ def self.peek_result(); end
1084
+
1085
+ def self.running?(); end
1086
+
1087
+ end
1088
+
1077
1089
  class Data
1078
1090
  extend ::T::Sig
1079
1091
  end
1080
1092
 
1093
+ class Date::Infinity
1094
+ def initialize(d=T.unsafe(nil)); end
1095
+ end
1096
+
1097
+ class Date::Infinity
1098
+ extend ::T::Sig
1099
+ end
1100
+
1101
+ class Date
1102
+ extend ::T::Sig
1103
+ end
1104
+
1105
+ class DateTime
1106
+ extend ::T::Sig
1107
+ end
1108
+
1081
1109
  class Delegator
1082
1110
  def !=(obj); end
1083
1111
 
@@ -1143,15 +1171,6 @@ module DidYouMean::Correctable
1143
1171
  extend ::T::Sig
1144
1172
  end
1145
1173
 
1146
- class DidYouMean::DeprecatedIgnoredCallers
1147
- def +(*_); end
1148
-
1149
- def <<(*_); end
1150
- end
1151
-
1152
- class DidYouMean::DeprecatedIgnoredCallers
1153
- end
1154
-
1155
1174
  module DidYouMean::Jaro
1156
1175
  extend ::T::Sig
1157
1176
  def self.distance(str1, str2); end
@@ -1188,6 +1207,7 @@ class DidYouMean::MethodNameChecker
1188
1207
  def method_names(); end
1189
1208
 
1190
1209
  def receiver(); end
1210
+ RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
1191
1211
  end
1192
1212
 
1193
1213
  class DidYouMean::MethodNameChecker
@@ -1235,7 +1255,7 @@ class DidYouMean::VariableNameChecker
1235
1255
  def method_names(); end
1236
1256
 
1237
1257
  def name(); end
1238
- RB_PREDEFINED_OBJECTS = ::T.let(nil, ::T.untyped)
1258
+ RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
1239
1259
  end
1240
1260
 
1241
1261
  class DidYouMean::VariableNameChecker
@@ -1269,6 +1289,13 @@ module Digest
1269
1289
  extend ::T::Sig
1270
1290
  end
1271
1291
 
1292
+ class Dir
1293
+ def children(); end
1294
+
1295
+ def each_child(); end
1296
+
1297
+ end
1298
+
1272
1299
  module Dir::Tmpname
1273
1300
  extend ::T::Sig
1274
1301
  end
@@ -1286,6 +1313,24 @@ class Dir
1286
1313
  def self.tmpdir(); end
1287
1314
  end
1288
1315
 
1316
+ module Docile
1317
+ VERSION = ::T.let(nil, ::T.untyped)
1318
+ end
1319
+
1320
+ module Docile::Execution
1321
+ extend ::T::Sig
1322
+ end
1323
+
1324
+ class Docile::FallbackContextProxy
1325
+ NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped)
1326
+ NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped)
1327
+ NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped)
1328
+ end
1329
+
1330
+ module Docile
1331
+ extend ::T::Sig
1332
+ end
1333
+
1289
1334
  class EOFError
1290
1335
  extend ::T::Sig
1291
1336
  end
@@ -1438,13 +1483,15 @@ class EncodingError
1438
1483
  end
1439
1484
 
1440
1485
  module Enumerable
1486
+ def chain(*_); end
1487
+
1441
1488
  def chunk(); end
1442
1489
 
1443
1490
  def chunk_while(); end
1444
1491
 
1445
1492
  def each_entry(*_); end
1446
1493
 
1447
- def each_with_object(_); end
1494
+ def filter(); end
1448
1495
 
1449
1496
  def grep_v(_); end
1450
1497
 
@@ -1469,8 +1516,38 @@ module Enumerable
1469
1516
  extend ::T::Sig
1470
1517
  end
1471
1518
 
1519
+ class Enumerator
1520
+ def +(_); end
1521
+
1522
+ def each_with_index(); end
1523
+
1524
+ end
1525
+
1526
+ class Enumerator::ArithmeticSequence
1527
+ def begin(); end
1528
+
1529
+ def each(&blk); end
1530
+
1531
+ def end(); end
1532
+
1533
+ def exclude_end?(); end
1534
+
1535
+ def last(*_); end
1536
+
1537
+ def step(); end
1538
+ end
1539
+
1540
+ class Enumerator::ArithmeticSequence
1541
+ end
1542
+
1543
+ class Enumerator::Chain
1544
+ end
1545
+
1546
+ class Enumerator::Chain
1547
+ end
1548
+
1472
1549
  class Enumerator::Generator
1473
- def each(*_); end
1550
+ def each(*_, &blk); end
1474
1551
 
1475
1552
  def initialize(*_); end
1476
1553
  end
@@ -1517,10 +1594,6 @@ class Errno::EADDRNOTAVAIL
1517
1594
  extend ::T::Sig
1518
1595
  end
1519
1596
 
1520
- class Errno::EADV
1521
- extend ::T::Sig
1522
- end
1523
-
1524
1597
  class Errno::EAFNOSUPPORT
1525
1598
  extend ::T::Sig
1526
1599
  end
@@ -1533,40 +1606,47 @@ class Errno::EALREADY
1533
1606
  extend ::T::Sig
1534
1607
  end
1535
1608
 
1536
- Errno::EAUTH = Errno::NOERROR
1609
+ class Errno::EAUTH
1610
+ Errno = ::T.let(nil, ::T.untyped)
1611
+ end
1537
1612
 
1538
- class Errno::EBADE
1539
- extend ::T::Sig
1613
+ class Errno::EAUTH
1540
1614
  end
1541
1615
 
1542
- class Errno::EBADF
1543
- extend ::T::Sig
1616
+ class Errno::EBADARCH
1617
+ Errno = ::T.let(nil, ::T.untyped)
1544
1618
  end
1545
1619
 
1546
- class Errno::EBADFD
1547
- extend ::T::Sig
1620
+ class Errno::EBADARCH
1548
1621
  end
1549
1622
 
1550
- class Errno::EBADMSG
1551
- extend ::T::Sig
1623
+ class Errno::EBADEXEC
1624
+ Errno = ::T.let(nil, ::T.untyped)
1625
+ end
1626
+
1627
+ class Errno::EBADEXEC
1552
1628
  end
1553
1629
 
1554
- class Errno::EBADR
1630
+ class Errno::EBADF
1555
1631
  extend ::T::Sig
1556
1632
  end
1557
1633
 
1558
- Errno::EBADRPC = Errno::NOERROR
1634
+ class Errno::EBADMACHO
1635
+ Errno = ::T.let(nil, ::T.untyped)
1636
+ end
1559
1637
 
1560
- class Errno::EBADRQC
1561
- extend ::T::Sig
1638
+ class Errno::EBADMACHO
1562
1639
  end
1563
1640
 
1564
- class Errno::EBADSLT
1641
+ class Errno::EBADMSG
1565
1642
  extend ::T::Sig
1566
1643
  end
1567
1644
 
1568
- class Errno::EBFONT
1569
- extend ::T::Sig
1645
+ class Errno::EBADRPC
1646
+ Errno = ::T.let(nil, ::T.untyped)
1647
+ end
1648
+
1649
+ class Errno::EBADRPC
1570
1650
  end
1571
1651
 
1572
1652
  class Errno::EBUSY
@@ -1583,14 +1663,6 @@ class Errno::ECHILD
1583
1663
  extend ::T::Sig
1584
1664
  end
1585
1665
 
1586
- class Errno::ECHRNG
1587
- extend ::T::Sig
1588
- end
1589
-
1590
- class Errno::ECOMM
1591
- extend ::T::Sig
1592
- end
1593
-
1594
1666
  class Errno::ECONNABORTED
1595
1667
  extend ::T::Sig
1596
1668
  end
@@ -1607,22 +1679,25 @@ class Errno::EDEADLK
1607
1679
  extend ::T::Sig
1608
1680
  end
1609
1681
 
1610
- Errno::EDEADLOCK = Errno::EDEADLK
1682
+ Errno::EDEADLOCK = Errno::NOERROR
1611
1683
 
1612
1684
  class Errno::EDESTADDRREQ
1613
1685
  extend ::T::Sig
1614
1686
  end
1615
1687
 
1616
- class Errno::EDOM
1617
- extend ::T::Sig
1688
+ class Errno::EDEVERR
1689
+ Errno = ::T.let(nil, ::T.untyped)
1618
1690
  end
1619
1691
 
1620
- Errno::EDOOFUS = Errno::NOERROR
1692
+ class Errno::EDEVERR
1693
+ end
1621
1694
 
1622
- class Errno::EDOTDOT
1695
+ class Errno::EDOM
1623
1696
  extend ::T::Sig
1624
1697
  end
1625
1698
 
1699
+ Errno::EDOOFUS = Errno::NOERROR
1700
+
1626
1701
  class Errno::EDQUOT
1627
1702
  extend ::T::Sig
1628
1703
  end
@@ -1639,7 +1714,12 @@ class Errno::EFBIG
1639
1714
  extend ::T::Sig
1640
1715
  end
1641
1716
 
1642
- Errno::EFTYPE = Errno::NOERROR
1717
+ class Errno::EFTYPE
1718
+ Errno = ::T.let(nil, ::T.untyped)
1719
+ end
1720
+
1721
+ class Errno::EFTYPE
1722
+ end
1643
1723
 
1644
1724
  class Errno::EHOSTDOWN
1645
1725
  extend ::T::Sig
@@ -1649,10 +1729,6 @@ class Errno::EHOSTUNREACH
1649
1729
  extend ::T::Sig
1650
1730
  end
1651
1731
 
1652
- class Errno::EHWPOISON
1653
- extend ::T::Sig
1654
- end
1655
-
1656
1732
  class Errno::EIDRM
1657
1733
  extend ::T::Sig
1658
1734
  end
@@ -1687,70 +1763,17 @@ class Errno::EISDIR
1687
1763
  extend ::T::Sig
1688
1764
  end
1689
1765
 
1690
- class Errno::EISNAM
1691
- extend ::T::Sig
1692
- end
1693
-
1694
- class Errno::EKEYEXPIRED
1695
- extend ::T::Sig
1696
- end
1697
-
1698
- class Errno::EKEYREJECTED
1699
- extend ::T::Sig
1700
- end
1701
-
1702
- class Errno::EKEYREVOKED
1703
- extend ::T::Sig
1704
- end
1705
-
1706
- class Errno::EL2HLT
1707
- extend ::T::Sig
1708
- end
1709
-
1710
- class Errno::EL2NSYNC
1711
- extend ::T::Sig
1712
- end
1713
-
1714
- class Errno::EL3HLT
1715
- extend ::T::Sig
1716
- end
1717
-
1718
- class Errno::EL3RST
1719
- extend ::T::Sig
1720
- end
1721
-
1722
- class Errno::ELIBACC
1723
- extend ::T::Sig
1724
- end
1725
-
1726
- class Errno::ELIBBAD
1727
- extend ::T::Sig
1728
- end
1729
-
1730
- class Errno::ELIBEXEC
1731
- extend ::T::Sig
1732
- end
1733
-
1734
- class Errno::ELIBMAX
1735
- extend ::T::Sig
1736
- end
1737
-
1738
- class Errno::ELIBSCN
1739
- extend ::T::Sig
1766
+ class Errno::ELAST
1767
+ Errno = ::T.let(nil, ::T.untyped)
1740
1768
  end
1741
1769
 
1742
- class Errno::ELNRNG
1743
- extend ::T::Sig
1770
+ class Errno::ELAST
1744
1771
  end
1745
1772
 
1746
1773
  class Errno::ELOOP
1747
1774
  extend ::T::Sig
1748
1775
  end
1749
1776
 
1750
- class Errno::EMEDIUMTYPE
1751
- extend ::T::Sig
1752
- end
1753
-
1754
1777
  class Errno::EMFILE
1755
1778
  extend ::T::Sig
1756
1779
  end
@@ -1771,11 +1794,12 @@ class Errno::ENAMETOOLONG
1771
1794
  extend ::T::Sig
1772
1795
  end
1773
1796
 
1774
- class Errno::ENAVAIL
1775
- extend ::T::Sig
1797
+ class Errno::ENEEDAUTH
1798
+ Errno = ::T.let(nil, ::T.untyped)
1776
1799
  end
1777
1800
 
1778
- Errno::ENEEDAUTH = Errno::NOERROR
1801
+ class Errno::ENEEDAUTH
1802
+ end
1779
1803
 
1780
1804
  class Errno::ENETDOWN
1781
1805
  extend ::T::Sig
@@ -1793,17 +1817,14 @@ class Errno::ENFILE
1793
1817
  extend ::T::Sig
1794
1818
  end
1795
1819
 
1796
- class Errno::ENOANO
1797
- extend ::T::Sig
1820
+ class Errno::ENOATTR
1821
+ Errno = ::T.let(nil, ::T.untyped)
1798
1822
  end
1799
1823
 
1800
- Errno::ENOATTR = Errno::NOERROR
1801
-
1802
- class Errno::ENOBUFS
1803
- extend ::T::Sig
1824
+ class Errno::ENOATTR
1804
1825
  end
1805
1826
 
1806
- class Errno::ENOCSI
1827
+ class Errno::ENOBUFS
1807
1828
  extend ::T::Sig
1808
1829
  end
1809
1830
 
@@ -1823,10 +1844,6 @@ class Errno::ENOEXEC
1823
1844
  extend ::T::Sig
1824
1845
  end
1825
1846
 
1826
- class Errno::ENOKEY
1827
- extend ::T::Sig
1828
- end
1829
-
1830
1847
  class Errno::ENOLCK
1831
1848
  extend ::T::Sig
1832
1849
  end
@@ -1835,10 +1852,6 @@ class Errno::ENOLINK
1835
1852
  extend ::T::Sig
1836
1853
  end
1837
1854
 
1838
- class Errno::ENOMEDIUM
1839
- extend ::T::Sig
1840
- end
1841
-
1842
1855
  class Errno::ENOMEM
1843
1856
  extend ::T::Sig
1844
1857
  end
@@ -1847,12 +1860,11 @@ class Errno::ENOMSG
1847
1860
  extend ::T::Sig
1848
1861
  end
1849
1862
 
1850
- class Errno::ENONET
1851
- extend ::T::Sig
1863
+ class Errno::ENOPOLICY
1864
+ Errno = ::T.let(nil, ::T.untyped)
1852
1865
  end
1853
1866
 
1854
- class Errno::ENOPKG
1855
- extend ::T::Sig
1867
+ class Errno::ENOPOLICY
1856
1868
  end
1857
1869
 
1858
1870
  class Errno::ENOPROTOOPT
@@ -1893,10 +1905,6 @@ class Errno::ENOTEMPTY
1893
1905
  extend ::T::Sig
1894
1906
  end
1895
1907
 
1896
- class Errno::ENOTNAM
1897
- extend ::T::Sig
1898
- end
1899
-
1900
1908
  class Errno::ENOTRECOVERABLE
1901
1909
  extend ::T::Sig
1902
1910
  end
@@ -1905,13 +1913,14 @@ class Errno::ENOTSOCK
1905
1913
  extend ::T::Sig
1906
1914
  end
1907
1915
 
1908
- Errno::ENOTSUP = Errno::EOPNOTSUPP
1916
+ class Errno::ENOTSUP
1917
+ Errno = ::T.let(nil, ::T.untyped)
1918
+ end
1909
1919
 
1910
- class Errno::ENOTTY
1911
- extend ::T::Sig
1920
+ class Errno::ENOTSUP
1912
1921
  end
1913
1922
 
1914
- class Errno::ENOTUNIQ
1923
+ class Errno::ENOTTY
1915
1924
  extend ::T::Sig
1916
1925
  end
1917
1926
 
@@ -1943,13 +1952,33 @@ class Errno::EPIPE
1943
1952
  extend ::T::Sig
1944
1953
  end
1945
1954
 
1946
- Errno::EPROCLIM = Errno::NOERROR
1955
+ class Errno::EPROCLIM
1956
+ Errno = ::T.let(nil, ::T.untyped)
1957
+ end
1958
+
1959
+ class Errno::EPROCLIM
1960
+ end
1961
+
1962
+ class Errno::EPROCUNAVAIL
1963
+ Errno = ::T.let(nil, ::T.untyped)
1964
+ end
1965
+
1966
+ class Errno::EPROCUNAVAIL
1967
+ end
1968
+
1969
+ class Errno::EPROGMISMATCH
1970
+ Errno = ::T.let(nil, ::T.untyped)
1971
+ end
1947
1972
 
1948
- Errno::EPROCUNAVAIL = Errno::NOERROR
1973
+ class Errno::EPROGMISMATCH
1974
+ end
1949
1975
 
1950
- Errno::EPROGMISMATCH = Errno::NOERROR
1976
+ class Errno::EPROGUNAVAIL
1977
+ Errno = ::T.let(nil, ::T.untyped)
1978
+ end
1951
1979
 
1952
- Errno::EPROGUNAVAIL = Errno::NOERROR
1980
+ class Errno::EPROGUNAVAIL
1981
+ end
1953
1982
 
1954
1983
  class Errno::EPROTO
1955
1984
  extend ::T::Sig
@@ -1963,11 +1992,16 @@ class Errno::EPROTOTYPE
1963
1992
  extend ::T::Sig
1964
1993
  end
1965
1994
 
1966
- class Errno::ERANGE
1967
- extend ::T::Sig
1995
+ class Errno::EPWROFF
1996
+ Errno = ::T.let(nil, ::T.untyped)
1997
+ end
1998
+
1999
+ class Errno::EPWROFF
1968
2000
  end
1969
2001
 
1970
- class Errno::EREMCHG
2002
+ Errno::EQFULL = Errno::ELAST
2003
+
2004
+ class Errno::ERANGE
1971
2005
  extend ::T::Sig
1972
2006
  end
1973
2007
 
@@ -1975,23 +2009,23 @@ class Errno::EREMOTE
1975
2009
  extend ::T::Sig
1976
2010
  end
1977
2011
 
1978
- class Errno::EREMOTEIO
2012
+ class Errno::EROFS
1979
2013
  extend ::T::Sig
1980
2014
  end
1981
2015
 
1982
- class Errno::ERESTART
1983
- extend ::T::Sig
2016
+ class Errno::ERPCMISMATCH
2017
+ Errno = ::T.let(nil, ::T.untyped)
1984
2018
  end
1985
2019
 
1986
- class Errno::ERFKILL
1987
- extend ::T::Sig
2020
+ class Errno::ERPCMISMATCH
1988
2021
  end
1989
2022
 
1990
- class Errno::EROFS
1991
- extend ::T::Sig
2023
+ class Errno::ESHLIBVERS
2024
+ Errno = ::T.let(nil, ::T.untyped)
1992
2025
  end
1993
2026
 
1994
- Errno::ERPCMISMATCH = Errno::NOERROR
2027
+ class Errno::ESHLIBVERS
2028
+ end
1995
2029
 
1996
2030
  class Errno::ESHUTDOWN
1997
2031
  extend ::T::Sig
@@ -2009,18 +2043,10 @@ class Errno::ESRCH
2009
2043
  extend ::T::Sig
2010
2044
  end
2011
2045
 
2012
- class Errno::ESRMNT
2013
- extend ::T::Sig
2014
- end
2015
-
2016
2046
  class Errno::ESTALE
2017
2047
  extend ::T::Sig
2018
2048
  end
2019
2049
 
2020
- class Errno::ESTRPIPE
2021
- extend ::T::Sig
2022
- end
2023
-
2024
2050
  class Errno::ETIME
2025
2051
  extend ::T::Sig
2026
2052
  end
@@ -2037,14 +2063,6 @@ class Errno::ETXTBSY
2037
2063
  extend ::T::Sig
2038
2064
  end
2039
2065
 
2040
- class Errno::EUCLEAN
2041
- extend ::T::Sig
2042
- end
2043
-
2044
- class Errno::EUNATCH
2045
- extend ::T::Sig
2046
- end
2047
-
2048
2066
  class Errno::EUSERS
2049
2067
  extend ::T::Sig
2050
2068
  end
@@ -2053,10 +2071,6 @@ class Errno::EXDEV
2053
2071
  extend ::T::Sig
2054
2072
  end
2055
2073
 
2056
- class Errno::EXFULL
2057
- extend ::T::Sig
2058
- end
2059
-
2060
2074
  class Errno::NOERROR
2061
2075
  extend ::T::Sig
2062
2076
  end
@@ -2088,16 +2102,24 @@ class Etc::Group
2088
2102
  extend ::Enumerable
2089
2103
  def self.[](*_); end
2090
2104
 
2091
- def self.each(); end
2105
+ def self.each(&blk); end
2092
2106
 
2093
2107
  def self.members(); end
2094
2108
  end
2095
2109
 
2096
2110
  class Etc::Passwd
2111
+ def change(); end
2112
+
2113
+ def change=(_); end
2114
+
2097
2115
  def dir(); end
2098
2116
 
2099
2117
  def dir=(_); end
2100
2118
 
2119
+ def expire(); end
2120
+
2121
+ def expire=(_); end
2122
+
2101
2123
  def gecos(); end
2102
2124
 
2103
2125
  def gecos=(_); end
@@ -2118,6 +2140,10 @@ class Etc::Passwd
2118
2140
 
2119
2141
  def shell=(_); end
2120
2142
 
2143
+ def uclass(); end
2144
+
2145
+ def uclass=(_); end
2146
+
2121
2147
  def uid(); end
2122
2148
 
2123
2149
  def uid=(_); end
@@ -2128,7 +2154,7 @@ class Etc::Passwd
2128
2154
  extend ::Enumerable
2129
2155
  def self.[](*_); end
2130
2156
 
2131
- def self.each(); end
2157
+ def self.each(&blk); end
2132
2158
 
2133
2159
  def self.members(); end
2134
2160
  end
@@ -2356,6 +2382,8 @@ class FileUtils::Entry_
2356
2382
 
2357
2383
  def initialize(a, b=T.unsafe(nil), deref=T.unsafe(nil)); end
2358
2384
 
2385
+ def link(dest); end
2386
+
2359
2387
  def lstat(); end
2360
2388
 
2361
2389
  def lstat!(); end
@@ -2466,6 +2494,8 @@ module FileUtils
2466
2494
 
2467
2495
  def self.cp(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
2468
2496
 
2497
+ def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
2498
+
2469
2499
  def self.getwd(); end
2470
2500
 
2471
2501
  def self.have_option?(mid, opt); end
@@ -2476,6 +2506,8 @@ module FileUtils
2476
2506
 
2477
2507
  def self.link(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
2478
2508
 
2509
+ def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
2510
+
2479
2511
  def self.ln(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
2480
2512
 
2481
2513
  def self.ln_s(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
@@ -2539,6 +2571,34 @@ class FloatDomainError
2539
2571
  extend ::T::Sig
2540
2572
  end
2541
2573
 
2574
+ module Forwardable
2575
+ def def_delegator(accessor, method, ali=T.unsafe(nil)); end
2576
+
2577
+ def def_delegators(accessor, *methods); end
2578
+
2579
+ def def_instance_delegator(accessor, method, ali=T.unsafe(nil)); end
2580
+
2581
+ def def_instance_delegators(accessor, *methods); end
2582
+
2583
+ def delegate(hash); end
2584
+
2585
+ def instance_delegate(hash); end
2586
+ VERSION = ::T.let(nil, ::T.untyped)
2587
+ end
2588
+
2589
+ module Forwardable
2590
+ extend ::T::Sig
2591
+ def self._compile_method(src, file, line); end
2592
+
2593
+ def self._delegator_method(obj, accessor, method, ali); end
2594
+
2595
+ def self._valid_method?(method); end
2596
+
2597
+ def self.debug(); end
2598
+
2599
+ def self.debug=(debug); end
2600
+ end
2601
+
2542
2602
  class FrozenError
2543
2603
  end
2544
2604
 
@@ -2560,6 +2620,8 @@ module GC
2560
2620
  def self.stress=(stress); end
2561
2621
 
2562
2622
  def self.verify_internal_consistency(); end
2623
+
2624
+ def self.verify_transient_heap_internal_consistency(); end
2563
2625
  end
2564
2626
 
2565
2627
  module Gem
@@ -2578,7 +2640,7 @@ class Gem::AvailableSet
2578
2640
 
2579
2641
  def all_specs(); end
2580
2642
 
2581
- def each(); end
2643
+ def each(&blk); end
2582
2644
 
2583
2645
  def each_spec(); end
2584
2646
 
@@ -2699,8 +2761,6 @@ end
2699
2761
  class Gem::BasicSpecification
2700
2762
  extend ::T::Sig
2701
2763
  def self.default_specifications_dir(); end
2702
-
2703
- def self.upstream_default_specifications_dir(); end
2704
2764
  end
2705
2765
 
2706
2766
  module Gem::BundlerVersionFinder
@@ -2724,6 +2784,7 @@ Gem::Cache = Gem::SourceIndex
2724
2784
  class Gem::Command
2725
2785
  include ::Gem::UserInteraction
2726
2786
  include ::Gem::DefaultUserInteraction
2787
+ include ::Gem::Text
2727
2788
  def add_extra_args(args); end
2728
2789
 
2729
2790
  def add_option(*opts, &handler); end
@@ -2820,6 +2881,7 @@ end
2820
2881
  class Gem::ConfigFile
2821
2882
  include ::Gem::UserInteraction
2822
2883
  include ::Gem::DefaultUserInteraction
2884
+ include ::Gem::Text
2823
2885
  def ==(other); end
2824
2886
 
2825
2887
  def [](key); end
@@ -2942,6 +3004,7 @@ class Gem::ConsoleUI
2942
3004
  end
2943
3005
 
2944
3006
  module Gem::DefaultUserInteraction
3007
+ include ::Gem::Text
2945
3008
  def ui(); end
2946
3009
 
2947
3010
  def ui=(new_ui); end
@@ -3031,6 +3094,7 @@ end
3031
3094
  class Gem::DependencyInstaller
3032
3095
  include ::Gem::UserInteraction
3033
3096
  include ::Gem::DefaultUserInteraction
3097
+ include ::Gem::Text
3034
3098
  def _deprecated_add_found_dependencies(to_do, dependency_list); end
3035
3099
 
3036
3100
  def _deprecated_gather_dependencies(); end
@@ -3175,6 +3239,7 @@ end
3175
3239
  class Gem::Ext::Builder
3176
3240
  include ::Gem::UserInteraction
3177
3241
  include ::Gem::DefaultUserInteraction
3242
+ include ::Gem::Text
3178
3243
  def build_args(); end
3179
3244
 
3180
3245
  def build_args=(build_args); end
@@ -3295,6 +3360,7 @@ end
3295
3360
  class Gem::Installer
3296
3361
  include ::Gem::UserInteraction
3297
3362
  include ::Gem::DefaultUserInteraction
3363
+ include ::Gem::Text
3298
3364
  def _deprecated_extension_build_error(build_dir, output, backtrace=T.unsafe(nil)); end
3299
3365
 
3300
3366
  def app_script_text(bin_file_name); end
@@ -3375,7 +3441,7 @@ class Gem::Installer
3375
3441
 
3376
3442
  def verify_gem_home(unpack=T.unsafe(nil)); end
3377
3443
 
3378
- def verify_spec_name(); end
3444
+ def verify_spec(); end
3379
3445
 
3380
3446
  def windows_stub_script(bindir, bin_file_name); end
3381
3447
 
@@ -3425,7 +3491,7 @@ class Gem::Licenses
3425
3491
  end
3426
3492
 
3427
3493
  class Gem::List
3428
- def each(); end
3494
+ def each(&blk); end
3429
3495
 
3430
3496
  def initialize(value=T.unsafe(nil), tail=T.unsafe(nil)); end
3431
3497
 
@@ -3519,6 +3585,7 @@ end
3519
3585
  class Gem::Package
3520
3586
  include ::Gem::UserInteraction
3521
3587
  include ::Gem::DefaultUserInteraction
3588
+ include ::Gem::Text
3522
3589
  def add_checksums(tar); end
3523
3590
 
3524
3591
  def add_contents(tar); end
@@ -3755,7 +3822,7 @@ class Gem::Package::TarReader
3755
3822
  include ::Enumerable
3756
3823
  def close(); end
3757
3824
 
3758
- def each(); end
3825
+ def each(&blk); end
3759
3826
 
3760
3827
  def each_entry(); end
3761
3828
 
@@ -3968,6 +4035,7 @@ end
3968
4035
  class Gem::RemoteFetcher
3969
4036
  include ::Gem::UserInteraction
3970
4037
  include ::Gem::DefaultUserInteraction
4038
+ include ::Gem::Text
3971
4039
  def cache_update_path(uri, path=T.unsafe(nil), update=T.unsafe(nil)); end
3972
4040
 
3973
4041
  def close_all(); end
@@ -4025,6 +4093,7 @@ end
4025
4093
  class Gem::Request
4026
4094
  include ::Gem::UserInteraction
4027
4095
  include ::Gem::DefaultUserInteraction
4096
+ include ::Gem::Text
4028
4097
  def cert_files(); end
4029
4098
 
4030
4099
  def connection_for(uri); end
@@ -4082,6 +4151,7 @@ end
4082
4151
  class Gem::Request
4083
4152
  extend ::Gem::UserInteraction
4084
4153
  extend ::Gem::DefaultUserInteraction
4154
+ extend ::Gem::Text
4085
4155
  def self.configure_connection_for_https(connection, cert_files); end
4086
4156
 
4087
4157
  def self.create_with_proxy(uri, request_class, last_modified, proxy); end
@@ -4782,7 +4852,7 @@ class Gem::Resolver::Molinillo::DependencyGraph
4782
4852
 
4783
4853
  def detach_vertex_named(name); end
4784
4854
 
4785
- def each(); end
4855
+ def each(&blk); end
4786
4856
 
4787
4857
  def rewind_to(tag); end
4788
4858
 
@@ -4900,7 +4970,7 @@ class Gem::Resolver::Molinillo::DependencyGraph::Log
4900
4970
 
4901
4971
  def detach_vertex_named(graph, name); end
4902
4972
 
4903
- def each(); end
4973
+ def each(&blk); end
4904
4974
 
4905
4975
  def pop!(graph); end
4906
4976
 
@@ -5205,7 +5275,7 @@ class Gem::Resolver::RequirementList
5205
5275
  include ::Enumerable
5206
5276
  def add(req); end
5207
5277
 
5208
- def each(); end
5278
+ def each(&blk); end
5209
5279
 
5210
5280
  def empty?(); end
5211
5281
 
@@ -5377,22 +5447,36 @@ end
5377
5447
  class Gem::Security::KEY_ALGORITHM
5378
5448
  def d(); end
5379
5449
 
5450
+ def d=(d); end
5451
+
5380
5452
  def dmp1(); end
5381
5453
 
5454
+ def dmp1=(dmp1); end
5455
+
5382
5456
  def dmq1(); end
5383
5457
 
5458
+ def dmq1=(dmq1); end
5459
+
5384
5460
  def e(); end
5385
5461
 
5462
+ def e=(e); end
5463
+
5386
5464
  def export(*_); end
5387
5465
 
5388
5466
  def initialize(*_); end
5389
5467
 
5390
5468
  def iqmp(); end
5391
5469
 
5470
+ def iqmp=(iqmp); end
5471
+
5392
5472
  def n(); end
5393
5473
 
5474
+ def n=(n); end
5475
+
5394
5476
  def p(); end
5395
5477
 
5478
+ def p=(p); end
5479
+
5396
5480
  def params(); end
5397
5481
 
5398
5482
  def private?(); end
@@ -5411,6 +5495,8 @@ class Gem::Security::KEY_ALGORITHM
5411
5495
 
5412
5496
  def q(); end
5413
5497
 
5498
+ def q=(q); end
5499
+
5414
5500
  def set_crt_params(_, _1, _2); end
5415
5501
 
5416
5502
  def set_factors(_, _1); end
@@ -5441,6 +5527,7 @@ end
5441
5527
  class Gem::Security::Policy
5442
5528
  include ::Gem::UserInteraction
5443
5529
  include ::Gem::DefaultUserInteraction
5530
+ include ::Gem::Text
5444
5531
  def check_cert(signer, issuer, time); end
5445
5532
 
5446
5533
  def check_chain(chain, time); end
@@ -5494,6 +5581,7 @@ end
5494
5581
  class Gem::Security::Signer
5495
5582
  include ::Gem::UserInteraction
5496
5583
  include ::Gem::DefaultUserInteraction
5584
+ include ::Gem::Text
5497
5585
  def cert_chain(); end
5498
5586
 
5499
5587
  def cert_chain=(cert_chain); end
@@ -5731,7 +5819,7 @@ class Gem::SourceList
5731
5819
 
5732
5820
  def delete(source); end
5733
5821
 
5734
- def each(); end
5822
+ def each(&blk); end
5735
5823
 
5736
5824
  def each_source(&b); end
5737
5825
 
@@ -6156,7 +6244,7 @@ class Gem::Specification
6156
6244
 
6157
6245
  def self.dirs=(dirs); end
6158
6246
 
6159
- def self.each(); end
6247
+ def self.each(&blk); end
6160
6248
 
6161
6249
  def self.each_gemspec(dirs); end
6162
6250
 
@@ -6398,6 +6486,7 @@ end
6398
6486
 
6399
6487
  module Gem::UserInteraction
6400
6488
  include ::Gem::DefaultUserInteraction
6489
+ include ::Gem::Text
6401
6490
  def alert(statement, question=T.unsafe(nil)); end
6402
6491
 
6403
6492
  def alert_error(statement, question=T.unsafe(nil)); end
@@ -6662,12 +6751,6 @@ module Gem
6662
6751
 
6663
6752
  def self.ui(); end
6664
6753
 
6665
- def self.upstream_default_bindir(); end
6666
-
6667
- def self.upstream_default_dir(); end
6668
-
6669
- def self.upstream_default_path(); end
6670
-
6671
6754
  def self.use_gemdeps(path=T.unsafe(nil)); end
6672
6755
 
6673
6756
  def self.use_paths(home, *paths); end
@@ -6705,11 +6788,13 @@ class Hash
6705
6788
 
6706
6789
  def fetch_values(*_); end
6707
6790
 
6791
+ def filter!(); end
6792
+
6708
6793
  def flatten(*_); end
6709
6794
 
6710
6795
  def index(_); end
6711
6796
 
6712
- def merge!(_); end
6797
+ def merge!(*_); end
6713
6798
 
6714
6799
  def replace(_); end
6715
6800
 
@@ -6727,7 +6812,7 @@ class Hash
6727
6812
 
6728
6813
  def transform_values!(); end
6729
6814
 
6730
- def update(_); end
6815
+ def update(*_); end
6731
6816
  end
6732
6817
 
6733
6818
  class Hash
@@ -7161,8 +7246,6 @@ module JSON
7161
7246
  end
7162
7247
 
7163
7248
  module Kernel
7164
- def class(); end
7165
-
7166
7249
  def gem(dep, *reqs); end
7167
7250
 
7168
7251
  def itself(); end
@@ -7173,6 +7256,8 @@ module Kernel
7173
7256
 
7174
7257
  def respond_to?(*_); end
7175
7258
 
7259
+ def then(); end
7260
+
7176
7261
  def yield_self(); end
7177
7262
  end
7178
7263
 
@@ -7244,8 +7329,12 @@ module Math
7244
7329
  end
7245
7330
 
7246
7331
  class Method
7332
+ def <<(_); end
7333
+
7247
7334
  def ===(*_); end
7248
7335
 
7336
+ def >>(_); end
7337
+
7249
7338
  def [](*_); end
7250
7339
 
7251
7340
  def arity(); end
@@ -7275,307 +7364,11 @@ class Method
7275
7364
  extend ::T::Sig
7276
7365
  end
7277
7366
 
7278
- module Minitest::Assertions
7279
- def _synchronize(); end
7280
-
7281
- def assert(test, msg=T.unsafe(nil)); end
7282
-
7283
- def assert_empty(obj, msg=T.unsafe(nil)); end
7284
-
7285
- def assert_equal(exp, act, msg=T.unsafe(nil)); end
7286
-
7287
- def assert_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
7288
-
7289
- def assert_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
7290
-
7291
- def assert_includes(collection, obj, msg=T.unsafe(nil)); end
7292
-
7293
- def assert_instance_of(cls, obj, msg=T.unsafe(nil)); end
7294
-
7295
- def assert_kind_of(cls, obj, msg=T.unsafe(nil)); end
7296
-
7297
- def assert_match(matcher, obj, msg=T.unsafe(nil)); end
7298
-
7299
- def assert_mock(mock); end
7300
-
7301
- def assert_nil(obj, msg=T.unsafe(nil)); end
7302
-
7303
- def assert_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
7304
-
7305
- def assert_output(stdout=T.unsafe(nil), stderr=T.unsafe(nil)); end
7306
-
7307
- def assert_predicate(o1, op, msg=T.unsafe(nil)); end
7308
-
7309
- def assert_raises(*exp); end
7310
-
7311
- def assert_respond_to(obj, meth, msg=T.unsafe(nil)); end
7312
-
7313
- def assert_same(exp, act, msg=T.unsafe(nil)); end
7314
-
7315
- def assert_send(send_ary, m=T.unsafe(nil)); end
7316
-
7317
- def assert_silent(); end
7318
-
7319
- def assert_throws(sym, msg=T.unsafe(nil)); end
7320
-
7321
- def capture_io(); end
7322
-
7323
- def capture_subprocess_io(); end
7324
-
7325
- def diff(exp, act); end
7326
-
7327
- def exception_details(e, msg); end
7328
-
7329
- def flunk(msg=T.unsafe(nil)); end
7330
-
7331
- def message(msg=T.unsafe(nil), ending=T.unsafe(nil), &default); end
7332
-
7333
- def mu_pp(obj); end
7334
-
7335
- def mu_pp_for_diff(obj); end
7336
-
7337
- def pass(_msg=T.unsafe(nil)); end
7338
-
7339
- def refute(test, msg=T.unsafe(nil)); end
7340
-
7341
- def refute_empty(obj, msg=T.unsafe(nil)); end
7342
-
7343
- def refute_equal(exp, act, msg=T.unsafe(nil)); end
7344
-
7345
- def refute_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
7346
-
7347
- def refute_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
7348
-
7349
- def refute_includes(collection, obj, msg=T.unsafe(nil)); end
7350
-
7351
- def refute_instance_of(cls, obj, msg=T.unsafe(nil)); end
7352
-
7353
- def refute_kind_of(cls, obj, msg=T.unsafe(nil)); end
7354
-
7355
- def refute_match(matcher, obj, msg=T.unsafe(nil)); end
7356
-
7357
- def refute_nil(obj, msg=T.unsafe(nil)); end
7358
-
7359
- def refute_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
7360
-
7361
- def refute_predicate(o1, op, msg=T.unsafe(nil)); end
7362
-
7363
- def refute_respond_to(obj, meth, msg=T.unsafe(nil)); end
7364
-
7365
- def refute_same(exp, act, msg=T.unsafe(nil)); end
7366
-
7367
- def skip(msg=T.unsafe(nil), bt=T.unsafe(nil)); end
7368
-
7369
- def skipped?(); end
7370
- E = ::T.let(nil, ::T.untyped)
7371
- UNDEFINED = ::T.let(nil, ::T.untyped)
7372
- end
7373
-
7374
- module Minitest::Assertions
7375
- extend ::T::Sig
7376
- def self.diff(); end
7377
-
7378
- def self.diff=(o); end
7379
- end
7380
-
7381
- module Minitest::Expectations
7382
- def must_be(*args); end
7383
-
7384
- def must_be_close_to(*args); end
7385
-
7386
- def must_be_empty(*args); end
7387
-
7388
- def must_be_instance_of(*args); end
7389
-
7390
- def must_be_kind_of(*args); end
7391
-
7392
- def must_be_nil(*args); end
7393
-
7394
- def must_be_same_as(*args); end
7395
-
7396
- def must_be_silent(*args); end
7397
-
7398
- def must_be_within_delta(*args); end
7399
-
7400
- def must_be_within_epsilon(*args); end
7401
-
7402
- def must_equal(*args); end
7403
-
7404
- def must_include(*args); end
7405
-
7406
- def must_match(*args); end
7407
-
7408
- def must_output(*args); end
7409
-
7410
- def must_raise(*args); end
7411
-
7412
- def must_respond_to(*args); end
7413
-
7414
- def must_throw(*args); end
7415
-
7416
- def wont_be(*args); end
7417
-
7418
- def wont_be_close_to(*args); end
7419
-
7420
- def wont_be_empty(*args); end
7421
-
7422
- def wont_be_instance_of(*args); end
7423
-
7424
- def wont_be_kind_of(*args); end
7425
-
7426
- def wont_be_nil(*args); end
7427
-
7428
- def wont_be_same_as(*args); end
7429
-
7430
- def wont_be_within_delta(*args); end
7431
-
7432
- def wont_be_within_epsilon(*args); end
7433
-
7434
- def wont_equal(*args); end
7435
-
7436
- def wont_include(*args); end
7437
-
7438
- def wont_match(*args); end
7439
-
7440
- def wont_respond_to(*args); end
7441
- end
7442
-
7443
- module Minitest::Expectations
7444
- extend ::T::Sig
7445
- end
7446
-
7447
- module Minitest::Guard
7448
- def jruby?(platform=T.unsafe(nil)); end
7449
-
7450
- def maglev?(platform=T.unsafe(nil)); end
7451
-
7452
- def mri?(platform=T.unsafe(nil)); end
7453
-
7454
- def rubinius?(platform=T.unsafe(nil)); end
7455
-
7456
- def windows?(platform=T.unsafe(nil)); end
7457
- end
7458
-
7459
- module Minitest::Guard
7460
- extend ::T::Sig
7461
- end
7462
-
7463
- class Minitest::Runnable
7464
- def assertions(); end
7465
-
7466
- def assertions=(assertions); end
7467
-
7468
- def failure(); end
7469
-
7470
- def failures(); end
7471
-
7472
- def failures=(failures); end
7473
-
7474
- def initialize(name); end
7475
-
7476
- def marshal_dump(); end
7477
-
7478
- def marshal_load(ary); end
7479
-
7480
- def name(); end
7481
-
7482
- def name=(o); end
7483
-
7484
- def passed?(); end
7485
-
7486
- def result_code(); end
7487
-
7488
- def run(); end
7489
-
7490
- def skipped?(); end
7491
- SIGNALS = ::T.let(nil, ::T.untyped)
7492
- end
7493
-
7494
- class Minitest::Runnable
7495
- def self.inherited(klass); end
7496
-
7497
- def self.methods_matching(re); end
7498
-
7499
- def self.on_signal(name, action); end
7500
-
7501
- def self.reset(); end
7502
-
7503
- def self.run(reporter, options=T.unsafe(nil)); end
7504
-
7505
- def self.run_one_method(klass, method_name, reporter); end
7506
-
7507
- def self.runnable_methods(); end
7508
-
7509
- def self.runnables(); end
7510
-
7511
- def self.with_info_handler(reporter, &block); end
7512
- end
7513
-
7514
- class Minitest::Test
7515
- include ::Minitest::Assertions
7516
- include ::Minitest::Test::LifecycleHooks
7517
- include ::Minitest::Guard
7518
- def capture_exceptions(); end
7519
-
7520
- def error?(); end
7521
-
7522
- def location(); end
7523
-
7524
- def time(); end
7525
-
7526
- def time=(time); end
7527
-
7528
- def time_it(); end
7529
-
7530
- def with_info_handler(&block); end
7531
- PASSTHROUGH_EXCEPTIONS = ::T.let(nil, ::T.untyped)
7532
- TEARDOWN_METHODS = ::T.let(nil, ::T.untyped)
7533
- end
7534
-
7535
- module Minitest::Test::LifecycleHooks
7536
- def after_setup(); end
7537
-
7538
- def after_teardown(); end
7539
-
7540
- def before_setup(); end
7541
-
7542
- def before_teardown(); end
7543
-
7544
- def setup(); end
7545
-
7546
- def teardown(); end
7547
- end
7548
-
7549
- module Minitest::Test::LifecycleHooks
7550
- extend ::T::Sig
7551
- end
7552
-
7553
- class Minitest::Test
7554
- extend ::Minitest::Guard
7555
- def self.i_suck_and_my_tests_are_order_dependent!(); end
7556
-
7557
- def self.io_lock(); end
7558
-
7559
- def self.io_lock=(io_lock); end
7560
-
7561
- def self.make_my_diffs_pretty!(); end
7562
-
7563
- def self.parallelize_me!(); end
7564
-
7565
- def self.test_order(); end
7566
- end
7567
-
7568
- class Minitest::Unit::TestCase
7569
- end
7570
-
7571
- class Minitest::Unit::TestCase
7572
- end
7367
+ Methods = T::Private::Methods
7573
7368
 
7574
7369
  class Module
7575
7370
  def deprecate_constant(*_); end
7576
7371
 
7577
- def infect_an_assertion(meth, new_name, dont_flip=T.unsafe(nil)); end
7578
-
7579
7372
  def undef_method(*_); end
7580
7373
  end
7581
7374
 
@@ -7702,10 +7495,9 @@ class Numeric
7702
7495
  end
7703
7496
 
7704
7497
  class Object
7705
- include ::Minitest::Expectations
7706
7498
  include ::PP::ObjectMixin
7707
7499
  include ::JSON::Ext::Generator::GeneratorMethods::Object
7708
- def stub(name, val_or_callable, *block_args); end
7500
+ def to_yaml(options=T.unsafe(nil)); end
7709
7501
  ARGF = ::T.let(nil, ::T.untyped)
7710
7502
  ARGV = ::T.let(nil, ::T.untyped)
7711
7503
  CROSS_COMPILING = ::T.let(nil, ::T.untyped)
@@ -7730,6 +7522,7 @@ end
7730
7522
 
7731
7523
  class Object
7732
7524
  extend ::T::Sig
7525
+ def self.yaml_tag(url); end
7733
7526
  end
7734
7527
 
7735
7528
  class ObjectSpace::WeakMap
@@ -7737,7 +7530,7 @@ class ObjectSpace::WeakMap
7737
7530
 
7738
7531
  def []=(_, _1); end
7739
7532
 
7740
- def each(); end
7533
+ def each(&blk); end
7741
7534
 
7742
7535
  def each_key(); end
7743
7536
 
@@ -8083,7 +7876,7 @@ class OptionParser::Switch
8083
7876
 
8084
7877
  def desc(); end
8085
7878
 
8086
- def initialize(pattern=T.unsafe(nil), conv=T.unsafe(nil), short=T.unsafe(nil), long=T.unsafe(nil), arg=T.unsafe(nil), desc=T.unsafe(nil), block=T.unsafe(nil)); end
7879
+ def initialize(pattern=T.unsafe(nil), conv=T.unsafe(nil), short=T.unsafe(nil), long=T.unsafe(nil), arg=T.unsafe(nil), desc=T.unsafe(nil), block=T.unsafe(nil), &_block); end
8087
7880
 
8088
7881
  def long(); end
8089
7882
 
@@ -8171,8 +7964,12 @@ class Pathname
8171
7964
  end
8172
7965
 
8173
7966
  class Proc
7967
+ def <<(_); end
7968
+
8174
7969
  def ===(*_); end
8175
7970
 
7971
+ def >>(_); end
7972
+
8176
7973
  def [](*_); end
8177
7974
 
8178
7975
  def clone(); end
@@ -8186,6 +7983,12 @@ class Proc
8186
7983
  extend ::T::Sig
8187
7984
  end
8188
7985
 
7986
+ module Process
7987
+ CLOCK_MONOTONIC_RAW_APPROX = ::T.let(nil, ::T.untyped)
7988
+ CLOCK_UPTIME_RAW = ::T.let(nil, ::T.untyped)
7989
+ CLOCK_UPTIME_RAW_APPROX = ::T.let(nil, ::T.untyped)
7990
+ end
7991
+
8189
7992
  module Process::GID
8190
7993
  extend ::T::Sig
8191
7994
  end
@@ -8241,540 +8044,2630 @@ module Process
8241
8044
 
8242
8045
  end
8243
8046
 
8244
- Queue = Thread::Queue
8047
+ module Psych
8048
+ LIBYAML_VERSION = ::T.let(nil, ::T.untyped)
8049
+ VERSION = ::T.let(nil, ::T.untyped)
8050
+ end
8245
8051
 
8246
- class RDoc::TestCase
8247
- def assert_directory(path); end
8052
+ class Psych::BadAlias
8053
+ end
8248
8054
 
8249
- def assert_file(path); end
8055
+ class Psych::BadAlias
8056
+ end
8250
8057
 
8251
- def blank_line(); end
8058
+ class Psych::ClassLoader
8059
+ def big_decimal(); end
8252
8060
 
8253
- def block(*contents); end
8061
+ def complex(); end
8254
8062
 
8255
- def comment(text, top_level=T.unsafe(nil)); end
8063
+ def date(); end
8256
8064
 
8257
- def doc(*contents); end
8065
+ def date_time(); end
8258
8066
 
8259
- def hard_break(); end
8067
+ def exception(); end
8260
8068
 
8261
- def head(level, text); end
8069
+ def load(klassname); end
8262
8070
 
8263
- def item(label=T.unsafe(nil), *parts); end
8071
+ def object(); end
8264
8072
 
8265
- def list(type=T.unsafe(nil), *items); end
8073
+ def psych_omap(); end
8266
8074
 
8267
- def para(*a); end
8075
+ def psych_set(); end
8268
8076
 
8269
- def raw(*contents); end
8077
+ def range(); end
8270
8078
 
8271
- def refute_file(path); end
8079
+ def rational(); end
8272
8080
 
8273
- def rule(weight); end
8081
+ def regexp(); end
8274
8082
 
8275
- def temp_dir(); end
8083
+ def struct(); end
8084
+
8085
+ def symbol(); end
8086
+
8087
+ def symbolize(sym); end
8088
+ BIG_DECIMAL = ::T.let(nil, ::T.untyped)
8089
+ CACHE = ::T.let(nil, ::T.untyped)
8090
+ COMPLEX = ::T.let(nil, ::T.untyped)
8091
+ DATE = ::T.let(nil, ::T.untyped)
8092
+ DATE_TIME = ::T.let(nil, ::T.untyped)
8093
+ EXCEPTION = ::T.let(nil, ::T.untyped)
8094
+ OBJECT = ::T.let(nil, ::T.untyped)
8095
+ PSYCH_OMAP = ::T.let(nil, ::T.untyped)
8096
+ PSYCH_SET = ::T.let(nil, ::T.untyped)
8097
+ RANGE = ::T.let(nil, ::T.untyped)
8098
+ RATIONAL = ::T.let(nil, ::T.untyped)
8099
+ REGEXP = ::T.let(nil, ::T.untyped)
8100
+ STRUCT = ::T.let(nil, ::T.untyped)
8101
+ SYMBOL = ::T.let(nil, ::T.untyped)
8102
+ end
8276
8103
 
8277
- def verb(*parts); end
8104
+ class Psych::ClassLoader::Restricted
8105
+ def initialize(classes, symbols); end
8106
+ end
8278
8107
 
8279
- def verbose_capture_io(); end
8108
+ class Psych::ClassLoader::Restricted
8280
8109
  end
8281
8110
 
8282
- class RDoc::TestCase
8111
+ class Psych::ClassLoader
8283
8112
  end
8284
8113
 
8285
- module RDoc::Text
8286
- def expand_tabs(text); end
8114
+ class Psych::Coder
8115
+ def [](k); end
8287
8116
 
8288
- def flush_left(text); end
8117
+ def []=(k, v); end
8289
8118
 
8290
- def markup(text); end
8119
+ def add(k, v); end
8291
8120
 
8292
- def normalize_comment(text); end
8121
+ def implicit(); end
8293
8122
 
8294
- def parse(text, format=T.unsafe(nil)); end
8123
+ def implicit=(implicit); end
8295
8124
 
8296
- def snippet(text, limit=T.unsafe(nil)); end
8125
+ def initialize(tag); end
8297
8126
 
8298
- def strip_hashes(text); end
8127
+ def map(tag=T.unsafe(nil), style=T.unsafe(nil)); end
8299
8128
 
8300
- def strip_newlines(text); end
8129
+ def map=(map); end
8301
8130
 
8302
- def strip_stars(text); end
8131
+ def object(); end
8303
8132
 
8304
- def to_html(text); end
8133
+ def object=(object); end
8305
8134
 
8306
- def wrap(txt, line_len=T.unsafe(nil)); end
8307
- MARKUP_FORMAT = ::T.let(nil, ::T.untyped)
8308
- TO_HTML_CHARACTERS = ::T.let(nil, ::T.untyped)
8309
- end
8135
+ def represent_map(tag, map); end
8310
8136
 
8311
- module RDoc::Text
8312
- extend ::T::Sig
8313
- def self.encode_fallback(character, encoding, fallback); end
8314
- end
8137
+ def represent_object(tag, obj); end
8315
8138
 
8316
- module RSpec
8317
- MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
8139
+ def represent_scalar(tag, value); end
8140
+
8141
+ def represent_seq(tag, list); end
8142
+
8143
+ def scalar(*args); end
8144
+
8145
+ def scalar=(value); end
8146
+
8147
+ def seq(); end
8148
+
8149
+ def seq=(list); end
8150
+
8151
+ def style(); end
8152
+
8153
+ def style=(style); end
8154
+
8155
+ def tag(); end
8156
+
8157
+ def tag=(tag); end
8158
+
8159
+ def type(); end
8318
8160
  end
8319
8161
 
8320
- class RSpec::CallerFilter
8321
- ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
8322
- IGNORE_REGEX = ::T.let(nil, ::T.untyped)
8323
- LIB_REGEX = ::T.let(nil, ::T.untyped)
8324
- RSPEC_LIBS = ::T.let(nil, ::T.untyped)
8162
+ class Psych::Coder
8325
8163
  end
8326
8164
 
8327
- class RSpec::Core::Configuration
8328
- DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
8329
- FAILED_STATUS = ::T.let(nil, ::T.untyped)
8330
- MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
8331
- PASSED_STATUS = ::T.let(nil, ::T.untyped)
8332
- PENDING_STATUS = ::T.let(nil, ::T.untyped)
8333
- RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
8334
- UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
8335
- VALID_STATUSES = ::T.let(nil, ::T.untyped)
8165
+ class Psych::DisallowedClass
8166
+ def initialize(klass_name); end
8336
8167
  end
8337
8168
 
8338
- module RSpec::Core::Configuration::ExposeCurrentExample
8339
- extend ::T::Sig
8169
+ class Psych::DisallowedClass
8340
8170
  end
8341
8171
 
8342
- module RSpec::Core::Configuration::Readers
8172
+ class Psych::Emitter
8173
+ def alias(_); end
8174
+
8175
+ def canonical(); end
8176
+
8177
+ def canonical=(canonical); end
8178
+
8179
+ def end_document(_); end
8180
+
8181
+ def indentation(); end
8182
+
8183
+ def indentation=(indentation); end
8184
+
8185
+ def initialize(*_); end
8186
+
8187
+ def line_width(); end
8188
+
8189
+ def line_width=(line_width); end
8190
+
8191
+ def scalar(_, _1, _2, _3, _4, _5); end
8192
+
8193
+ def start_document(_, _1, _2); end
8194
+
8195
+ def start_mapping(_, _1, _2, _3); end
8196
+
8197
+ def start_sequence(_, _1, _2, _3); end
8198
+
8199
+ def start_stream(_); end
8200
+ end
8201
+
8202
+ class Psych::Emitter
8203
+ end
8204
+
8205
+ class Psych::Exception
8206
+ end
8207
+
8208
+ class Psych::Exception
8209
+ end
8210
+
8211
+ class Psych::Handler
8212
+ def alias(anchor); end
8213
+
8214
+ def empty(); end
8215
+
8216
+ def end_document(implicit); end
8217
+
8218
+ def end_mapping(); end
8219
+
8220
+ def end_sequence(); end
8221
+
8222
+ def end_stream(); end
8223
+
8224
+ def event_location(start_line, start_column, end_line, end_column); end
8225
+
8226
+ def scalar(value, anchor, tag, plain, quoted, style); end
8227
+
8228
+ def start_document(version, tag_directives, implicit); end
8229
+
8230
+ def start_mapping(anchor, tag, implicit, style); end
8231
+
8232
+ def start_sequence(anchor, tag, implicit, style); end
8233
+
8234
+ def start_stream(encoding); end
8235
+
8236
+ def streaming?(); end
8237
+ EVENTS = ::T.let(nil, ::T.untyped)
8238
+ OPTIONS = ::T.let(nil, ::T.untyped)
8239
+ end
8240
+
8241
+ class Psych::Handler::DumperOptions
8242
+ def canonical(); end
8243
+
8244
+ def canonical=(canonical); end
8245
+
8246
+ def indentation(); end
8247
+
8248
+ def indentation=(indentation); end
8249
+
8250
+ def line_width(); end
8251
+
8252
+ def line_width=(line_width); end
8253
+ end
8254
+
8255
+ class Psych::Handler::DumperOptions
8256
+ end
8257
+
8258
+ class Psych::Handler
8259
+ end
8260
+
8261
+ module Psych::Handlers
8262
+ end
8263
+
8264
+ class Psych::Handlers::DocumentStream
8265
+ def initialize(&block); end
8266
+ end
8267
+
8268
+ class Psych::Handlers::DocumentStream
8269
+ end
8270
+
8271
+ module Psych::Handlers
8272
+ extend ::T::Sig
8273
+ end
8274
+
8275
+ module Psych::JSON
8276
+ end
8277
+
8278
+ module Psych::JSON::RubyEvents
8279
+ def visit_DateTime(o); end
8280
+
8281
+ def visit_String(o); end
8282
+
8283
+ def visit_Symbol(o); end
8284
+
8285
+ def visit_Time(o); end
8286
+ end
8287
+
8288
+ module Psych::JSON::RubyEvents
8289
+ extend ::T::Sig
8290
+ end
8291
+
8292
+ class Psych::JSON::Stream
8293
+ include ::Psych::Streaming
8294
+ end
8295
+
8296
+ class Psych::JSON::Stream::Emitter
8297
+ include ::Psych::JSON::YAMLEvents
8298
+ end
8299
+
8300
+ class Psych::JSON::Stream::Emitter
8301
+ end
8302
+
8303
+ class Psych::JSON::Stream
8304
+ extend ::Psych::Streaming::ClassMethods
8305
+ end
8306
+
8307
+ class Psych::JSON::TreeBuilder
8308
+ include ::Psych::JSON::YAMLEvents
8309
+ end
8310
+
8311
+ class Psych::JSON::TreeBuilder
8312
+ end
8313
+
8314
+ module Psych::JSON::YAMLEvents
8315
+ def end_document(implicit_end=T.unsafe(nil)); end
8316
+
8317
+ def scalar(value, anchor, tag, plain, quoted, style); end
8318
+
8319
+ def start_document(version, tag_directives, implicit); end
8320
+
8321
+ def start_mapping(anchor, tag, implicit, style); end
8322
+
8323
+ def start_sequence(anchor, tag, implicit, style); end
8324
+ end
8325
+
8326
+ module Psych::JSON::YAMLEvents
8327
+ extend ::T::Sig
8328
+ end
8329
+
8330
+ module Psych::JSON
8331
+ extend ::T::Sig
8332
+ end
8333
+
8334
+ module Psych::Nodes
8335
+ end
8336
+
8337
+ class Psych::Nodes::Alias
8338
+ def anchor(); end
8339
+
8340
+ def anchor=(anchor); end
8341
+
8342
+ def initialize(anchor); end
8343
+ end
8344
+
8345
+ class Psych::Nodes::Alias
8346
+ end
8347
+
8348
+ class Psych::Nodes::Document
8349
+ def implicit(); end
8350
+
8351
+ def implicit=(implicit); end
8352
+
8353
+ def implicit_end(); end
8354
+
8355
+ def implicit_end=(implicit_end); end
8356
+
8357
+ def initialize(version=T.unsafe(nil), tag_directives=T.unsafe(nil), implicit=T.unsafe(nil)); end
8358
+
8359
+ def root(); end
8360
+
8361
+ def tag_directives(); end
8362
+
8363
+ def tag_directives=(tag_directives); end
8364
+
8365
+ def version(); end
8366
+
8367
+ def version=(version); end
8368
+ end
8369
+
8370
+ class Psych::Nodes::Document
8371
+ end
8372
+
8373
+ class Psych::Nodes::Mapping
8374
+ def anchor(); end
8375
+
8376
+ def anchor=(anchor); end
8377
+
8378
+ def implicit(); end
8379
+
8380
+ def implicit=(implicit); end
8381
+
8382
+ def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
8383
+
8384
+ def style(); end
8385
+
8386
+ def style=(style); end
8387
+
8388
+ def tag=(tag); end
8389
+ ANY = ::T.let(nil, ::T.untyped)
8390
+ BLOCK = ::T.let(nil, ::T.untyped)
8391
+ FLOW = ::T.let(nil, ::T.untyped)
8392
+ end
8393
+
8394
+ class Psych::Nodes::Mapping
8395
+ end
8396
+
8397
+ class Psych::Nodes::Node
8398
+ include ::Enumerable
8399
+ def alias?(); end
8400
+
8401
+ def children(); end
8402
+
8403
+ def document?(); end
8404
+
8405
+ def each(&block); end
8406
+
8407
+ def end_column(); end
8408
+
8409
+ def end_column=(end_column); end
8410
+
8411
+ def end_line(); end
8412
+
8413
+ def end_line=(end_line); end
8414
+
8415
+ def mapping?(); end
8416
+
8417
+ def scalar?(); end
8418
+
8419
+ def sequence?(); end
8420
+
8421
+ def start_column(); end
8422
+
8423
+ def start_column=(start_column); end
8424
+
8425
+ def start_line(); end
8426
+
8427
+ def start_line=(start_line); end
8428
+
8429
+ def stream?(); end
8430
+
8431
+ def tag(); end
8432
+
8433
+ def to_ruby(); end
8434
+
8435
+ def to_yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
8436
+
8437
+ def transform(); end
8438
+
8439
+ def yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
8440
+ end
8441
+
8442
+ class Psych::Nodes::Node
8443
+ end
8444
+
8445
+ class Psych::Nodes::Scalar
8446
+ def anchor(); end
8447
+
8448
+ def anchor=(anchor); end
8449
+
8450
+ def initialize(value, anchor=T.unsafe(nil), tag=T.unsafe(nil), plain=T.unsafe(nil), quoted=T.unsafe(nil), style=T.unsafe(nil)); end
8451
+
8452
+ def plain(); end
8453
+
8454
+ def plain=(plain); end
8455
+
8456
+ def quoted(); end
8457
+
8458
+ def quoted=(quoted); end
8459
+
8460
+ def style(); end
8461
+
8462
+ def style=(style); end
8463
+
8464
+ def tag=(tag); end
8465
+
8466
+ def value(); end
8467
+
8468
+ def value=(value); end
8469
+ ANY = ::T.let(nil, ::T.untyped)
8470
+ DOUBLE_QUOTED = ::T.let(nil, ::T.untyped)
8471
+ FOLDED = ::T.let(nil, ::T.untyped)
8472
+ LITERAL = ::T.let(nil, ::T.untyped)
8473
+ PLAIN = ::T.let(nil, ::T.untyped)
8474
+ SINGLE_QUOTED = ::T.let(nil, ::T.untyped)
8475
+ end
8476
+
8477
+ class Psych::Nodes::Scalar
8478
+ end
8479
+
8480
+ class Psych::Nodes::Sequence
8481
+ def anchor(); end
8482
+
8483
+ def anchor=(anchor); end
8484
+
8485
+ def implicit(); end
8486
+
8487
+ def implicit=(implicit); end
8488
+
8489
+ def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
8490
+
8491
+ def style(); end
8492
+
8493
+ def style=(style); end
8494
+
8495
+ def tag=(tag); end
8496
+ ANY = ::T.let(nil, ::T.untyped)
8497
+ BLOCK = ::T.let(nil, ::T.untyped)
8498
+ FLOW = ::T.let(nil, ::T.untyped)
8499
+ end
8500
+
8501
+ class Psych::Nodes::Sequence
8502
+ end
8503
+
8504
+ class Psych::Nodes::Stream
8505
+ def encoding(); end
8506
+
8507
+ def encoding=(encoding); end
8508
+
8509
+ def initialize(encoding=T.unsafe(nil)); end
8510
+ ANY = ::T.let(nil, ::T.untyped)
8511
+ UTF16BE = ::T.let(nil, ::T.untyped)
8512
+ UTF16LE = ::T.let(nil, ::T.untyped)
8513
+ UTF8 = ::T.let(nil, ::T.untyped)
8514
+ end
8515
+
8516
+ class Psych::Nodes::Stream
8517
+ end
8518
+
8519
+ module Psych::Nodes
8520
+ extend ::T::Sig
8521
+ end
8522
+
8523
+ class Psych::Omap
8524
+ end
8525
+
8526
+ class Psych::Omap
8527
+ end
8528
+
8529
+ class Psych::Parser
8530
+ def external_encoding=(external_encoding); end
8531
+
8532
+ def handler(); end
8533
+
8534
+ def handler=(handler); end
8535
+
8536
+ def initialize(handler=T.unsafe(nil)); end
8537
+
8538
+ def mark(); end
8539
+
8540
+ def parse(*_); end
8541
+ ANY = ::T.let(nil, ::T.untyped)
8542
+ UTF16BE = ::T.let(nil, ::T.untyped)
8543
+ UTF16LE = ::T.let(nil, ::T.untyped)
8544
+ UTF8 = ::T.let(nil, ::T.untyped)
8545
+ end
8546
+
8547
+ class Psych::Parser::Mark
8548
+ end
8549
+
8550
+ class Psych::Parser::Mark
8551
+ end
8552
+
8553
+ class Psych::Parser
8554
+ end
8555
+
8556
+ class Psych::ScalarScanner
8557
+ def class_loader(); end
8558
+
8559
+ def initialize(class_loader); end
8560
+
8561
+ def parse_int(string); end
8562
+
8563
+ def parse_time(string); end
8564
+
8565
+ def tokenize(string); end
8566
+ FLOAT = ::T.let(nil, ::T.untyped)
8567
+ INTEGER = ::T.let(nil, ::T.untyped)
8568
+ TIME = ::T.let(nil, ::T.untyped)
8569
+ end
8570
+
8571
+ class Psych::ScalarScanner
8572
+ end
8573
+
8574
+ class Psych::Set
8575
+ end
8576
+
8577
+ class Psych::Set
8578
+ end
8579
+
8580
+ class Psych::Stream
8581
+ include ::Psych::Streaming
8582
+ end
8583
+
8584
+ class Psych::Stream::Emitter
8585
+ def end_document(implicit_end=T.unsafe(nil)); end
8586
+ end
8587
+
8588
+ class Psych::Stream::Emitter
8589
+ end
8590
+
8591
+ class Psych::Stream
8592
+ extend ::Psych::Streaming::ClassMethods
8593
+ end
8594
+
8595
+ module Psych::Streaming
8596
+ def start(encoding=T.unsafe(nil)); end
8597
+ end
8598
+
8599
+ module Psych::Streaming::ClassMethods
8600
+ def new(io); end
8601
+ end
8602
+
8603
+ module Psych::Streaming::ClassMethods
8604
+ extend ::T::Sig
8605
+ end
8606
+
8607
+ module Psych::Streaming
8608
+ extend ::T::Sig
8609
+ end
8610
+
8611
+ class Psych::SyntaxError
8612
+ def column(); end
8613
+
8614
+ def context(); end
8615
+
8616
+ def file(); end
8617
+
8618
+ def initialize(file, line, col, offset, problem, context); end
8619
+
8620
+ def line(); end
8621
+
8622
+ def offset(); end
8623
+
8624
+ def problem(); end
8625
+ end
8626
+
8627
+ class Psych::SyntaxError
8628
+ end
8629
+
8630
+ class Psych::TreeBuilder
8631
+ def end_document(implicit_end=T.unsafe(nil)); end
8632
+
8633
+ def root(); end
8634
+ end
8635
+
8636
+ class Psych::TreeBuilder
8637
+ end
8638
+
8639
+ module Psych::Visitors
8640
+ end
8641
+
8642
+ class Psych::Visitors::DepthFirst
8643
+ def initialize(block); end
8644
+ end
8645
+
8646
+ class Psych::Visitors::DepthFirst
8647
+ end
8648
+
8649
+ class Psych::Visitors::Emitter
8650
+ def initialize(io, options=T.unsafe(nil)); end
8651
+
8652
+ def visit_Psych_Nodes_Alias(o); end
8653
+
8654
+ def visit_Psych_Nodes_Document(o); end
8655
+
8656
+ def visit_Psych_Nodes_Mapping(o); end
8657
+
8658
+ def visit_Psych_Nodes_Scalar(o); end
8659
+
8660
+ def visit_Psych_Nodes_Sequence(o); end
8661
+
8662
+ def visit_Psych_Nodes_Stream(o); end
8663
+ end
8664
+
8665
+ class Psych::Visitors::Emitter
8666
+ end
8667
+
8668
+ class Psych::Visitors::JSONTree
8669
+ include ::Psych::JSON::RubyEvents
8670
+ end
8671
+
8672
+ class Psych::Visitors::JSONTree
8673
+ def self.create(options=T.unsafe(nil)); end
8674
+ end
8675
+
8676
+ class Psych::Visitors::NoAliasRuby
8677
+ end
8678
+
8679
+ class Psych::Visitors::NoAliasRuby
8680
+ end
8681
+
8682
+ class Psych::Visitors::ToRuby
8683
+ def class_loader(); end
8684
+
8685
+ def initialize(ss, class_loader); end
8686
+
8687
+ def visit_Psych_Nodes_Alias(o); end
8688
+
8689
+ def visit_Psych_Nodes_Document(o); end
8690
+
8691
+ def visit_Psych_Nodes_Mapping(o); end
8692
+
8693
+ def visit_Psych_Nodes_Scalar(o); end
8694
+
8695
+ def visit_Psych_Nodes_Sequence(o); end
8696
+
8697
+ def visit_Psych_Nodes_Stream(o); end
8698
+ SHOVEL = ::T.let(nil, ::T.untyped)
8699
+ end
8700
+
8701
+ class Psych::Visitors::ToRuby
8702
+ def self.create(); end
8703
+ end
8704
+
8705
+ class Psych::Visitors::Visitor
8706
+ def accept(target); end
8707
+ DISPATCH = ::T.let(nil, ::T.untyped)
8708
+ end
8709
+
8710
+ class Psych::Visitors::Visitor
8711
+ end
8712
+
8713
+ class Psych::Visitors::YAMLTree
8714
+ def <<(object); end
8715
+
8716
+ def finish(); end
8717
+
8718
+ def finished(); end
8719
+
8720
+ def finished?(); end
8721
+
8722
+ def initialize(emitter, ss, options); end
8723
+
8724
+ def push(object); end
8725
+
8726
+ def start(encoding=T.unsafe(nil)); end
8727
+
8728
+ def started(); end
8729
+
8730
+ def started?(); end
8731
+
8732
+ def tree(); end
8733
+
8734
+ def visit_Array(o); end
8735
+
8736
+ def visit_BasicObject(o); end
8737
+
8738
+ def visit_BigDecimal(o); end
8739
+
8740
+ def visit_Class(o); end
8741
+
8742
+ def visit_Complex(o); end
8743
+
8744
+ def visit_Date(o); end
8745
+
8746
+ def visit_DateTime(o); end
8747
+
8748
+ def visit_Delegator(o); end
8749
+
8750
+ def visit_Encoding(o); end
8751
+
8752
+ def visit_Enumerator(o); end
8753
+
8754
+ def visit_Exception(o); end
8755
+
8756
+ def visit_FalseClass(o); end
8757
+
8758
+ def visit_Float(o); end
8759
+
8760
+ def visit_Hash(o); end
8761
+
8762
+ def visit_Integer(o); end
8763
+
8764
+ def visit_Module(o); end
8765
+
8766
+ def visit_NameError(o); end
8767
+
8768
+ def visit_NilClass(o); end
8769
+
8770
+ def visit_Object(o); end
8771
+
8772
+ def visit_Psych_Omap(o); end
8773
+
8774
+ def visit_Psych_Set(o); end
8775
+
8776
+ def visit_Range(o); end
8777
+
8778
+ def visit_Rational(o); end
8779
+
8780
+ def visit_Regexp(o); end
8781
+
8782
+ def visit_String(o); end
8783
+
8784
+ def visit_Struct(o); end
8785
+
8786
+ def visit_Symbol(o); end
8787
+
8788
+ def visit_Time(o); end
8789
+
8790
+ def visit_TrueClass(o); end
8791
+ end
8792
+
8793
+ class Psych::Visitors::YAMLTree
8794
+ def self.create(options=T.unsafe(nil), emitter=T.unsafe(nil)); end
8795
+ end
8796
+
8797
+ module Psych::Visitors
8798
+ extend ::T::Sig
8799
+ end
8800
+
8801
+ module Psych
8802
+ extend ::T::Sig
8803
+ def self.add_builtin_type(type_tag, &block); end
8804
+
8805
+ def self.add_domain_type(domain, type_tag, &block); end
8806
+
8807
+ def self.add_tag(tag, klass); end
8808
+
8809
+ def self.domain_types(); end
8810
+
8811
+ def self.domain_types=(domain_types); end
8812
+
8813
+ def self.dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end
8814
+
8815
+ def self.dump_stream(*objects); end
8816
+
8817
+ def self.dump_tags(); end
8818
+
8819
+ def self.dump_tags=(dump_tags); end
8820
+
8821
+ def self.libyaml_version(); end
8822
+
8823
+ def self.load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
8824
+
8825
+ def self.load_file(filename, fallback: T.unsafe(nil)); end
8826
+
8827
+ def self.load_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
8828
+
8829
+ def self.load_tags(); end
8830
+
8831
+ def self.load_tags=(load_tags); end
8832
+
8833
+ def self.parse(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
8834
+
8835
+ def self.parse_file(filename, fallback: T.unsafe(nil)); end
8836
+
8837
+ def self.parse_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), &block); end
8838
+
8839
+ def self.parser(); end
8840
+
8841
+ def self.remove_type(type_tag); end
8842
+
8843
+ def self.safe_load(yaml, legacy_permitted_classes=T.unsafe(nil), legacy_permitted_symbols=T.unsafe(nil), legacy_aliases=T.unsafe(nil), legacy_filename=T.unsafe(nil), permitted_classes: T.unsafe(nil), permitted_symbols: T.unsafe(nil), aliases: T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
8844
+
8845
+ def self.to_json(object); end
8846
+ end
8847
+
8848
+ Queue = Thread::Queue
8849
+
8850
+ module RDoc::Text
8851
+ def expand_tabs(text); end
8852
+
8853
+ def flush_left(text); end
8854
+
8855
+ def markup(text); end
8856
+
8857
+ def normalize_comment(text); end
8858
+
8859
+ def parse(text, format=T.unsafe(nil)); end
8860
+
8861
+ def snippet(text, limit=T.unsafe(nil)); end
8862
+
8863
+ def strip_hashes(text); end
8864
+
8865
+ def strip_newlines(text); end
8866
+
8867
+ def strip_stars(text); end
8868
+
8869
+ def to_html(text); end
8870
+
8871
+ def wrap(txt, line_len=T.unsafe(nil)); end
8872
+ MARKUP_FORMAT = ::T.let(nil, ::T.untyped)
8873
+ TO_HTML_CHARACTERS = ::T.let(nil, ::T.untyped)
8874
+ end
8875
+
8876
+ module RDoc::Text
8877
+ extend ::T::Sig
8878
+ def self.encode_fallback(character, encoding, fallback); end
8879
+ end
8880
+
8881
+ module RSpec
8882
+ MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
8883
+ end
8884
+
8885
+ class RSpec::CallerFilter
8886
+ ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
8887
+ IGNORE_REGEX = ::T.let(nil, ::T.untyped)
8888
+ LIB_REGEX = ::T.let(nil, ::T.untyped)
8889
+ RSPEC_LIBS = ::T.let(nil, ::T.untyped)
8890
+ end
8891
+
8892
+ class RSpec::Core::Configuration
8893
+ DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
8894
+ FAILED_STATUS = ::T.let(nil, ::T.untyped)
8895
+ MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
8896
+ PASSED_STATUS = ::T.let(nil, ::T.untyped)
8897
+ PENDING_STATUS = ::T.let(nil, ::T.untyped)
8898
+ RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
8899
+ UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
8900
+ VALID_STATUSES = ::T.let(nil, ::T.untyped)
8901
+ end
8902
+
8903
+ module RSpec::Core::Configuration::ExposeCurrentExample
8904
+ extend ::T::Sig
8905
+ end
8906
+
8907
+ module RSpec::Core::Configuration::Readers
8908
+ extend ::T::Sig
8909
+ end
8910
+
8911
+ class RSpec::Core::ConfigurationOptions
8912
+ OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
8913
+ UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
8914
+ UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
8915
+ end
8916
+
8917
+ module RSpec::Core::DSL
8918
+ extend ::T::Sig
8919
+ end
8920
+
8921
+ RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
8922
+
8923
+ class RSpec::Core::ExampleGroup
8924
+ include ::RSpec::Core::MockingAdapters::RSpec
8925
+ include ::RSpec::Mocks::ExampleMethods
8926
+ include ::RSpec::Mocks::ArgumentMatchers
8927
+ include ::RSpec::Mocks::ExampleMethods::ExpectHost
8928
+ include ::RSpec::Matchers
8929
+ INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
8930
+ end
8931
+
8932
+ class RSpec::Core::ExampleStatusPersister
8933
+ def initialize(examples, file_name); end
8934
+
8935
+ def persist(); end
8936
+ end
8937
+
8938
+ class RSpec::Core::ExampleStatusPersister
8939
+ def self.load_from(file_name); end
8940
+
8941
+ def self.persist(examples, file_name); end
8942
+ end
8943
+
8944
+ RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
8945
+
8946
+ class RSpec::Core::FilterRules
8947
+ PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
8948
+ PROJECT_DIR = ::T.let(nil, ::T.untyped)
8949
+ end
8950
+
8951
+ module RSpec::Core::FilterableItemRepository
8952
+ extend ::T::Sig
8953
+ end
8954
+
8955
+ module RSpec::Core::FlatMap
8956
+ extend ::T::Sig
8957
+ end
8958
+
8959
+ class RSpec::Core::Formatters::BaseBisectFormatter
8960
+ def example_failed(notification); end
8961
+
8962
+ def example_finished(notification); end
8963
+
8964
+ def initialize(expected_failures); end
8965
+
8966
+ def start_dump(_notification); end
8967
+ end
8968
+
8969
+ class RSpec::Core::Formatters::BaseBisectFormatter
8970
+ def self.inherited(formatter); end
8971
+ end
8972
+
8973
+ class RSpec::Core::Formatters::BaseFormatter
8974
+ def close(_notification); end
8975
+
8976
+ def example_group(); end
8977
+
8978
+ def example_group=(example_group); end
8979
+
8980
+ def example_group_started(notification); end
8981
+
8982
+ def initialize(output); end
8983
+
8984
+ def output(); end
8985
+
8986
+ def start(notification); end
8987
+ end
8988
+
8989
+ class RSpec::Core::Formatters::BaseFormatter
8990
+ end
8991
+
8992
+ class RSpec::Core::Formatters::BaseTextFormatter
8993
+ def dump_failures(notification); end
8994
+
8995
+ def dump_pending(notification); end
8996
+
8997
+ def dump_summary(summary); end
8998
+
8999
+ def message(notification); end
9000
+
9001
+ def seed(notification); end
9002
+ end
9003
+
9004
+ class RSpec::Core::Formatters::BaseTextFormatter
9005
+ end
9006
+
9007
+ class RSpec::Core::Formatters::BisectDRbFormatter
9008
+ def initialize(_output); end
9009
+
9010
+ def notify_results(results); end
9011
+ end
9012
+
9013
+ class RSpec::Core::Formatters::BisectDRbFormatter
9014
+ end
9015
+
9016
+ module RSpec::Core::Formatters::ConsoleCodes
9017
+ VT100_CODES = ::T.let(nil, ::T.untyped)
9018
+ VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
9019
+ end
9020
+
9021
+ module RSpec::Core::Formatters::ConsoleCodes
9022
+ extend ::T::Sig
9023
+ end
9024
+
9025
+ class RSpec::Core::Formatters::DeprecationFormatter
9026
+ DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
9027
+ RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
9028
+ TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
9029
+ end
9030
+
9031
+ class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
9032
+ TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
9033
+ end
9034
+
9035
+ class RSpec::Core::Formatters::DocumentationFormatter
9036
+ def example_failed(failure); end
9037
+
9038
+ def example_group_finished(_notification); end
9039
+
9040
+ def example_passed(passed); end
9041
+
9042
+ def example_pending(pending); end
9043
+ end
9044
+
9045
+ class RSpec::Core::Formatters::DocumentationFormatter
9046
+ end
9047
+
9048
+ class RSpec::Core::Formatters::ExceptionPresenter
9049
+ PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
9050
+ end
9051
+
9052
+ module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
9053
+ extend ::T::Sig
9054
+ end
9055
+
9056
+ class RSpec::Core::Formatters::FallbackMessageFormatter
9057
+ def initialize(output); end
9058
+
9059
+ def message(notification); end
9060
+
9061
+ def output(); end
9062
+ end
9063
+
9064
+ class RSpec::Core::Formatters::FallbackMessageFormatter
9065
+ end
9066
+
9067
+ module RSpec::Core::Formatters::Helpers
9068
+ DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
9069
+ SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
9070
+ end
9071
+
9072
+ module RSpec::Core::Formatters::Helpers
9073
+ extend ::T::Sig
9074
+ end
9075
+
9076
+ class RSpec::Core::Formatters::HtmlFormatter
9077
+ def dump_summary(summary); end
9078
+
9079
+ def example_failed(failure); end
9080
+
9081
+ def example_passed(passed); end
9082
+
9083
+ def example_pending(pending); end
9084
+
9085
+ def example_started(_notification); end
9086
+
9087
+ def start_dump(_notification); end
9088
+ end
9089
+
9090
+ class RSpec::Core::Formatters::HtmlFormatter
9091
+ end
9092
+
9093
+ class RSpec::Core::Formatters::JsonFormatter
9094
+ def dump_profile(profile); end
9095
+
9096
+ def dump_profile_slowest_example_groups(profile); end
9097
+
9098
+ def dump_profile_slowest_examples(profile); end
9099
+
9100
+ def dump_summary(summary); end
9101
+
9102
+ def message(notification); end
9103
+
9104
+ def output_hash(); end
9105
+
9106
+ def seed(notification); end
9107
+
9108
+ def stop(notification); end
9109
+ end
9110
+
9111
+ class RSpec::Core::Formatters::JsonFormatter
9112
+ end
9113
+
9114
+ class RSpec::Core::Formatters::ProfileFormatter
9115
+ def dump_profile(profile); end
9116
+
9117
+ def initialize(output); end
9118
+
9119
+ def output(); end
9120
+ end
9121
+
9122
+ class RSpec::Core::Formatters::ProfileFormatter
9123
+ end
9124
+
9125
+ class RSpec::Core::Formatters::ProgressFormatter
9126
+ def example_failed(_notification); end
9127
+
9128
+ def example_passed(_notification); end
9129
+
9130
+ def example_pending(_notification); end
9131
+
9132
+ def start_dump(_notification); end
9133
+ end
9134
+
9135
+ class RSpec::Core::Formatters::ProgressFormatter
9136
+ end
9137
+
9138
+ module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
9139
+ RESET_CODE = ::T.let(nil, ::T.untyped)
9140
+ end
9141
+
9142
+ module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
9143
+ extend ::T::Sig
9144
+ end
9145
+
9146
+ module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
9147
+ extend ::T::Sig
9148
+ end
9149
+
9150
+ RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
9151
+
9152
+ module RSpec::Core::Formatters
9153
+ extend ::T::Sig
9154
+ end
9155
+
9156
+ module RSpec::Core::HashImitatable::ClassMethods
9157
+ extend ::T::Sig
9158
+ end
9159
+
9160
+ module RSpec::Core::HashImitatable
9161
+ extend ::T::Sig
9162
+ end
9163
+
9164
+ class RSpec::Core::Hooks::HookCollections
9165
+ EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
9166
+ HOOK_TYPES = ::T.let(nil, ::T.untyped)
9167
+ SCOPES = ::T.let(nil, ::T.untyped)
9168
+ SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
9169
+ end
9170
+
9171
+ module RSpec::Core::Hooks
9172
+ extend ::T::Sig
9173
+ end
9174
+
9175
+ module RSpec::Core::Invocations
9176
+ extend ::T::Sig
9177
+ end
9178
+
9179
+ module RSpec::Core::MemoizedHelpers::ClassMethods
9180
+ extend ::T::Sig
9181
+ end
9182
+
9183
+ module RSpec::Core::MemoizedHelpers
9184
+ extend ::T::Sig
9185
+ end
9186
+
9187
+ module RSpec::Core::Metadata
9188
+ RESERVED_KEYS = ::T.let(nil, ::T.untyped)
9189
+ end
9190
+
9191
+ module RSpec::Core::Metadata
9192
+ extend ::T::Sig
9193
+ end
9194
+
9195
+ module RSpec::Core::MetadataFilter
9196
+ extend ::T::Sig
9197
+ end
9198
+
9199
+ module RSpec::Core::MockingAdapters::RSpec
9200
+ extend ::T::Sig
9201
+ end
9202
+
9203
+ module RSpec::Core::MockingAdapters
9204
+ extend ::T::Sig
9205
+ end
9206
+
9207
+ module RSpec::Core::MultipleExceptionError::InterfaceTag
9208
+ extend ::T::Sig
9209
+ end
9210
+
9211
+ module RSpec::Core::Notifications::NullColorizer
9212
+ extend ::T::Sig
9213
+ end
9214
+
9215
+ module RSpec::Core::Notifications
9216
+ extend ::T::Sig
9217
+ end
9218
+
9219
+ class RSpec::Core::Ordering::Random
9220
+ MAX_32_BIT = ::T.let(nil, ::T.untyped)
9221
+ end
9222
+
9223
+ module RSpec::Core::Ordering
9224
+ extend ::T::Sig
9225
+ end
9226
+
9227
+ module RSpec::Core::Pending
9228
+ NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
9229
+ NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
9230
+ end
9231
+
9232
+ module RSpec::Core::Pending
9233
+ extend ::T::Sig
9234
+ end
9235
+
9236
+ class RSpec::Core::Profiler
9237
+ def example_group_finished(notification); end
9238
+
9239
+ def example_group_started(notification); end
9240
+
9241
+ def example_groups(); end
9242
+
9243
+ def example_started(notification); end
9244
+ NOTIFICATIONS = ::T.let(nil, ::T.untyped)
9245
+ end
9246
+
9247
+ class RSpec::Core::Profiler
9248
+ end
9249
+
9250
+ class RSpec::Core::Reporter
9251
+ RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
9252
+ end
9253
+
9254
+ module RSpec::Core::RubyProject
9255
+ extend ::T::Sig
9256
+ end
9257
+
9258
+ module RSpec::Core::SharedContext
9259
+ def __shared_context_recordings(); end
9260
+
9261
+ def after(*args, &block); end
9262
+
9263
+ def append_after(*args, &block); end
9264
+
9265
+ def append_before(*args, &block); end
9266
+
9267
+ def around(*args, &block); end
9268
+
9269
+ def before(*args, &block); end
9270
+
9271
+ def context(*args, &block); end
9272
+
9273
+ def describe(*args, &block); end
9274
+
9275
+ def hooks(*args, &block); end
9276
+
9277
+ def included(group); end
9278
+
9279
+ def let(*args, &block); end
9280
+
9281
+ def let!(*args, &block); end
9282
+
9283
+ def prepend_after(*args, &block); end
9284
+
9285
+ def prepend_before(*args, &block); end
9286
+
9287
+ def subject(*args, &block); end
9288
+
9289
+ def subject!(*args, &block); end
9290
+ end
9291
+
9292
+ class RSpec::Core::SharedContext::Recording
9293
+ def args(); end
9294
+
9295
+ def args=(_); end
9296
+
9297
+ def block(); end
9298
+
9299
+ def block=(_); end
9300
+
9301
+ def method_name(); end
9302
+
9303
+ def method_name=(_); end
9304
+
9305
+ def playback_onto(group); end
9306
+ end
9307
+
9308
+ class RSpec::Core::SharedContext::Recording
9309
+ def self.[](*_); end
9310
+
9311
+ def self.members(); end
9312
+ end
9313
+
9314
+ module RSpec::Core::SharedContext
9315
+ extend ::T::Sig
9316
+ def self.record(methods); end
9317
+ end
9318
+
9319
+ module RSpec::Core::SharedExampleGroup::TopLevelDSL
9320
+ extend ::T::Sig
9321
+ end
9322
+
9323
+ module RSpec::Core::SharedExampleGroup
9324
+ extend ::T::Sig
9325
+ end
9326
+
9327
+ module RSpec::Core::ShellEscape
9328
+ SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
9329
+ end
9330
+
9331
+ module RSpec::Core::ShellEscape
9332
+ extend ::T::Sig
9333
+ end
9334
+
9335
+ module RSpec::Core::Version
9336
+ STRING = ::T.let(nil, ::T.untyped)
9337
+ end
9338
+
9339
+ module RSpec::Core::Version
9340
+ extend ::T::Sig
9341
+ end
9342
+
9343
+ module RSpec::Core::Warnings
9344
+ extend ::T::Sig
9345
+ end
9346
+
9347
+ module RSpec::Core::World::Null
9348
+ extend ::T::Sig
9349
+ end
9350
+
9351
+ module RSpec::Core
9352
+ extend ::T::Sig
9353
+ end
9354
+
9355
+ module RSpec::ExampleGroups
9356
+ extend ::T::Sig
9357
+ end
9358
+
9359
+ class RSpec::Expectations::BlockSnippetExtractor
9360
+ def body_content_lines(); end
9361
+
9362
+ def initialize(proc, method_name); end
9363
+
9364
+ def method_name(); end
9365
+ end
9366
+
9367
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError
9368
+ end
9369
+
9370
+ class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError
9371
+ end
9372
+
9373
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator
9374
+ def beginning_line_number(); end
9375
+
9376
+ def beginning_line_number=(_); end
9377
+
9378
+ def body_content_locations(); end
9379
+
9380
+ def method_call_location(); end
9381
+
9382
+ def method_name(); end
9383
+
9384
+ def method_name=(_); end
9385
+
9386
+ def source(); end
9387
+
9388
+ def source=(_); end
9389
+ end
9390
+
9391
+ class RSpec::Expectations::BlockSnippetExtractor::BlockLocator
9392
+ def self.[](*_); end
9393
+
9394
+ def self.members(); end
9395
+ end
9396
+
9397
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor
9398
+ def beginning_line_number(); end
9399
+
9400
+ def beginning_line_number=(_); end
9401
+
9402
+ def body_tokens(); end
9403
+
9404
+ def method_name(); end
9405
+
9406
+ def method_name=(_); end
9407
+
9408
+ def source(); end
9409
+
9410
+ def source=(_); end
9411
+
9412
+ def state(); end
9413
+ end
9414
+
9415
+ class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor
9416
+ def self.[](*_); end
9417
+
9418
+ def self.members(); end
9419
+ end
9420
+
9421
+ class RSpec::Expectations::BlockSnippetExtractor::Error
9422
+ end
9423
+
9424
+ class RSpec::Expectations::BlockSnippetExtractor::Error
9425
+ end
9426
+
9427
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError
9428
+ end
9429
+
9430
+ class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError
9431
+ end
9432
+
9433
+ class RSpec::Expectations::BlockSnippetExtractor
9434
+ def self.try_extracting_single_line_body_of(proc, method_name); end
9435
+ end
9436
+
9437
+ class RSpec::Expectations::Configuration
9438
+ FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped)
9439
+ end
9440
+
9441
+ module RSpec::Expectations::Configuration::NullBacktraceFormatter
9442
+ extend ::T::Sig
9443
+ end
9444
+
9445
+ module RSpec::Expectations::ExpectationHelper
9446
+ extend ::T::Sig
9447
+ end
9448
+
9449
+ module RSpec::Expectations::ExpectationTarget::InstanceMethods
9450
+ extend ::T::Sig
9451
+ end
9452
+
9453
+ module RSpec::Expectations::ExpectationTarget::UndefinedValue
9454
+ extend ::T::Sig
9455
+ end
9456
+
9457
+ class RSpec::Expectations::FailureAggregator
9458
+ def aggregate(); end
9459
+
9460
+ def block_label(); end
9461
+
9462
+ def call(failure, options); end
9463
+
9464
+ def failures(); end
9465
+
9466
+ def initialize(block_label, metadata); end
9467
+
9468
+ def metadata(); end
9469
+
9470
+ def other_errors(); end
9471
+ end
9472
+
9473
+ class RSpec::Expectations::FailureAggregator
9474
+ end
9475
+
9476
+ RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
9477
+
9478
+ class RSpec::Expectations::MultipleExpectationsNotMetError
9479
+ include ::RSpec::Core::MultipleExceptionError::InterfaceTag
9480
+ def aggregation_block_label(); end
9481
+
9482
+ def aggregation_metadata(); end
9483
+
9484
+ def all_exceptions(); end
9485
+
9486
+ def exception_count_description(); end
9487
+
9488
+ def failures(); end
9489
+
9490
+ def initialize(failure_aggregator); end
9491
+
9492
+ def other_errors(); end
9493
+
9494
+ def summary(); end
9495
+ end
9496
+
9497
+ module RSpec::Expectations::Syntax
9498
+ extend ::T::Sig
9499
+ end
9500
+
9501
+ module RSpec::Expectations::Version
9502
+ STRING = ::T.let(nil, ::T.untyped)
9503
+ end
9504
+
9505
+ module RSpec::Expectations::Version
9506
+ extend ::T::Sig
9507
+ end
9508
+
9509
+ module RSpec::Expectations
9510
+ extend ::T::Sig
9511
+ end
9512
+
9513
+ module RSpec::Matchers
9514
+ def log(*expected, &block_arg); end
9515
+
9516
+ def not_log(*expected, &block_arg); end
9517
+ BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped)
9518
+ DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped)
9519
+ HAS_REGEX = ::T.let(nil, ::T.untyped)
9520
+ end
9521
+
9522
+ RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
9523
+
9524
+ class RSpec::Matchers::BuiltIn::All
9525
+ def does_not_match?(_actual); end
9526
+
9527
+ def failed_objects(); end
9528
+
9529
+ def initialize(matcher); end
9530
+
9531
+ def matcher(); end
9532
+ end
9533
+
9534
+ class RSpec::Matchers::BuiltIn::All
9535
+ end
9536
+
9537
+ class RSpec::Matchers::BuiltIn::BaseMatcher
9538
+ UNDEFINED = ::T.let(nil, ::T.untyped)
9539
+ end
9540
+
9541
+ module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
9542
+ extend ::T::Sig
9543
+ end
9544
+
9545
+ module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
9546
+ extend ::T::Sig
9547
+ end
9548
+
9549
+ class RSpec::Matchers::BuiltIn::Be
9550
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
9551
+ def <(operand); end
9552
+
9553
+ def <=(operand); end
9554
+
9555
+ def ==(operand); end
9556
+
9557
+ def ===(operand); end
9558
+
9559
+ def =~(operand); end
9560
+
9561
+ def >(operand); end
9562
+
9563
+ def >=(operand); end
9564
+
9565
+ def initialize(*args); end
9566
+ end
9567
+
9568
+ class RSpec::Matchers::BuiltIn::Be
9569
+ end
9570
+
9571
+ class RSpec::Matchers::BuiltIn::BeAKindOf
9572
+ end
9573
+
9574
+ class RSpec::Matchers::BuiltIn::BeAKindOf
9575
+ end
9576
+
9577
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf
9578
+ end
9579
+
9580
+ class RSpec::Matchers::BuiltIn::BeAnInstanceOf
9581
+ end
9582
+
9583
+ class RSpec::Matchers::BuiltIn::BeBetween
9584
+ def exclusive(); end
9585
+
9586
+ def inclusive(); end
9587
+
9588
+ def initialize(min, max); end
9589
+ end
9590
+
9591
+ class RSpec::Matchers::BuiltIn::BeBetween
9592
+ end
9593
+
9594
+ class RSpec::Matchers::BuiltIn::BeComparedTo
9595
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
9596
+ def initialize(operand, operator); end
9597
+ end
9598
+
9599
+ class RSpec::Matchers::BuiltIn::BeComparedTo
9600
+ end
9601
+
9602
+ class RSpec::Matchers::BuiltIn::BeFalsey
9603
+ end
9604
+
9605
+ class RSpec::Matchers::BuiltIn::BeFalsey
9606
+ end
9607
+
9608
+ module RSpec::Matchers::BuiltIn::BeHelpers
9609
+ end
9610
+
9611
+ module RSpec::Matchers::BuiltIn::BeHelpers
8343
9612
  extend ::T::Sig
8344
9613
  end
8345
9614
 
8346
- class RSpec::Core::ConfigurationOptions
8347
- OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
8348
- UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
8349
- UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
9615
+ class RSpec::Matchers::BuiltIn::BeNil
9616
+ end
9617
+
9618
+ class RSpec::Matchers::BuiltIn::BeNil
9619
+ end
9620
+
9621
+ class RSpec::Matchers::BuiltIn::BePredicate
9622
+ include ::RSpec::Matchers::BuiltIn::BeHelpers
9623
+ def does_not_match?(actual, &block); end
9624
+
9625
+ def initialize(*args, &block); end
9626
+
9627
+ def matches?(actual, &block); end
9628
+ end
9629
+
9630
+ class RSpec::Matchers::BuiltIn::BePredicate
9631
+ end
9632
+
9633
+ class RSpec::Matchers::BuiltIn::BeTruthy
9634
+ end
9635
+
9636
+ class RSpec::Matchers::BuiltIn::BeTruthy
9637
+ end
9638
+
9639
+ class RSpec::Matchers::BuiltIn::BeWithin
9640
+ def initialize(delta); end
9641
+
9642
+ def of(expected); end
9643
+
9644
+ def percent_of(expected); end
9645
+ end
9646
+
9647
+ class RSpec::Matchers::BuiltIn::BeWithin
9648
+ end
9649
+
9650
+ class RSpec::Matchers::BuiltIn::Change
9651
+ def by(expected_delta); end
9652
+
9653
+ def by_at_least(minimum); end
9654
+
9655
+ def by_at_most(maximum); end
9656
+
9657
+ def does_not_match?(event_proc); end
9658
+
9659
+ def from(value); end
9660
+
9661
+ def initialize(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end
9662
+
9663
+ def matches?(event_proc); end
9664
+
9665
+ def to(value); end
9666
+ end
9667
+
9668
+ class RSpec::Matchers::BuiltIn::Change
9669
+ end
9670
+
9671
+ class RSpec::Matchers::BuiltIn::Compound
9672
+ def diffable_matcher_list(); end
9673
+
9674
+ def does_not_match?(_actual); end
9675
+
9676
+ def evaluator(); end
9677
+
9678
+ def initialize(matcher_1, matcher_2); end
9679
+
9680
+ def matcher_1(); end
9681
+
9682
+ def matcher_2(); end
9683
+ end
9684
+
9685
+ class RSpec::Matchers::BuiltIn::Compound::And
9686
+ end
9687
+
9688
+ class RSpec::Matchers::BuiltIn::Compound::And
9689
+ end
9690
+
9691
+ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
9692
+ def initialize(actual, matcher_1, matcher_2); end
9693
+
9694
+ def matcher_matches?(matcher); end
9695
+ end
9696
+
9697
+ class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
9698
+ def self.matcher_expects_call_stack_jump?(matcher); end
9699
+ end
9700
+
9701
+ class RSpec::Matchers::BuiltIn::Compound::Or
9702
+ end
9703
+
9704
+ class RSpec::Matchers::BuiltIn::Compound::Or
9705
+ end
9706
+
9707
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
9708
+ def initialize(actual, *_); end
9709
+
9710
+ def matcher_matches?(matcher); end
9711
+ end
9712
+
9713
+ class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
9714
+ end
9715
+
9716
+ class RSpec::Matchers::BuiltIn::Compound
9717
+ end
9718
+
9719
+ class RSpec::Matchers::BuiltIn::ContainExactly
9720
+ end
9721
+
9722
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
9723
+ def actual_to_expected_matched_indexes(); end
9724
+
9725
+ def expected_to_actual_matched_indexes(); end
9726
+
9727
+ def find_best_solution(); end
9728
+
9729
+ def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
9730
+
9731
+ def solution(); end
9732
+ end
9733
+
9734
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
9735
+ end
9736
+
9737
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
9738
+ def self.worse_than?(_other); end
9739
+ end
9740
+
9741
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution
9742
+ def +(derived_candidate_solution); end
9743
+
9744
+ def candidate?(); end
9745
+
9746
+ def ideal?(); end
9747
+
9748
+ def indeterminate_actual_indexes(); end
9749
+
9750
+ def indeterminate_actual_indexes=(_); end
9751
+
9752
+ def indeterminate_expected_indexes(); end
9753
+
9754
+ def indeterminate_expected_indexes=(_); end
9755
+
9756
+ def unmatched_actual_indexes(); end
9757
+
9758
+ def unmatched_actual_indexes=(_); end
9759
+
9760
+ def unmatched_expected_indexes(); end
9761
+
9762
+ def unmatched_expected_indexes=(_); end
9763
+
9764
+ def unmatched_item_count(); end
9765
+
9766
+ def worse_than?(other); end
9767
+ end
9768
+
9769
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution
9770
+ def self.[](*_); end
9771
+
9772
+ def self.members(); end
9773
+ end
9774
+
9775
+ class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
9776
+ end
9777
+
9778
+ class RSpec::Matchers::BuiltIn::ContainExactly
9779
+ end
9780
+
9781
+ class RSpec::Matchers::BuiltIn::Cover
9782
+ def does_not_match?(range); end
9783
+
9784
+ def initialize(*expected); end
9785
+
9786
+ def matches?(range); end
9787
+ end
9788
+
9789
+ class RSpec::Matchers::BuiltIn::Cover
9790
+ end
9791
+
9792
+ class RSpec::Matchers::BuiltIn::EndWith
9793
+ end
9794
+
9795
+ class RSpec::Matchers::BuiltIn::EndWith
9796
+ end
9797
+
9798
+ class RSpec::Matchers::BuiltIn::Eq
9799
+ end
9800
+
9801
+ class RSpec::Matchers::BuiltIn::Eq
9802
+ end
9803
+
9804
+ class RSpec::Matchers::BuiltIn::Eql
9805
+ end
9806
+
9807
+ class RSpec::Matchers::BuiltIn::Eql
9808
+ end
9809
+
9810
+ class RSpec::Matchers::BuiltIn::Equal
9811
+ LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped)
9812
+ end
9813
+
9814
+ class RSpec::Matchers::BuiltIn::Equal
9815
+ end
9816
+
9817
+ class RSpec::Matchers::BuiltIn::Exist
9818
+ def does_not_match?(actual); end
9819
+
9820
+ def initialize(*expected); end
9821
+ end
9822
+
9823
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest
9824
+ def actual_exists?(); end
9825
+
9826
+ def valid_test?(); end
9827
+
9828
+ def validity_message(); end
9829
+ end
9830
+
9831
+ class RSpec::Matchers::BuiltIn::Exist::ExistenceTest
9832
+ end
9833
+
9834
+ class RSpec::Matchers::BuiltIn::Exist
9835
+ end
9836
+
9837
+ class RSpec::Matchers::BuiltIn::Has
9838
+ def does_not_match?(actual, &block); end
9839
+
9840
+ def initialize(method_name, *args, &block); end
9841
+
9842
+ def matches?(actual, &block); end
9843
+ end
9844
+
9845
+ class RSpec::Matchers::BuiltIn::Has
9846
+ end
9847
+
9848
+ class RSpec::Matchers::BuiltIn::HaveAttributes
9849
+ def does_not_match?(actual); end
9850
+
9851
+ def initialize(expected); end
9852
+
9853
+ def respond_to_failed(); end
9854
+ end
9855
+
9856
+ class RSpec::Matchers::BuiltIn::HaveAttributes
9857
+ end
9858
+
9859
+ class RSpec::Matchers::BuiltIn::Include
9860
+ def does_not_match?(actual); end
9861
+
9862
+ def expecteds(); end
9863
+
9864
+ def initialize(*expecteds); end
9865
+ end
9866
+
9867
+ class RSpec::Matchers::BuiltIn::Include
9868
+ end
9869
+
9870
+ class RSpec::Matchers::BuiltIn::Match
9871
+ def initialize(expected); end
9872
+
9873
+ def with_captures(*captures); end
9874
+ end
9875
+
9876
+ class RSpec::Matchers::BuiltIn::Match
9877
+ end
9878
+
9879
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher
9880
+ def __delegate_operator(actual, operator, expected); end
9881
+ end
9882
+
9883
+ class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher
9884
+ end
9885
+
9886
+ class RSpec::Matchers::BuiltIn::OperatorMatcher
9887
+ def !=(_expected); end
9888
+
9889
+ def !~(_expected); end
9890
+
9891
+ def <(expected); end
9892
+
9893
+ def <=(expected); end
9894
+
9895
+ def ==(expected); end
9896
+
9897
+ def ===(expected); end
9898
+
9899
+ def =~(expected); end
9900
+
9901
+ def >(expected); end
9902
+
9903
+ def >=(expected); end
9904
+
9905
+ def description(); end
9906
+
9907
+ def fail_with_message(message); end
9908
+
9909
+ def initialize(actual); end
9910
+ end
9911
+
9912
+ class RSpec::Matchers::BuiltIn::OperatorMatcher
9913
+ def self.get(klass, operator); end
9914
+
9915
+ def self.register(klass, operator, matcher); end
9916
+
9917
+ def self.registry(); end
9918
+
9919
+ def self.unregister(klass, operator); end
9920
+
9921
+ def self.use_custom_matcher_or_delegate(operator); end
9922
+ end
9923
+
9924
+ class RSpec::Matchers::BuiltIn::Output
9925
+ def does_not_match?(block); end
9926
+
9927
+ def initialize(expected); end
9928
+
9929
+ def matches?(block); end
9930
+
9931
+ def to_stderr(); end
9932
+
9933
+ def to_stderr_from_any_process(); end
9934
+
9935
+ def to_stdout(); end
9936
+
9937
+ def to_stdout_from_any_process(); end
9938
+ end
9939
+
9940
+ class RSpec::Matchers::BuiltIn::Output
9941
+ end
9942
+
9943
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher
9944
+ def __delegate_operator(actual, operator, expected); end
9945
+ end
9946
+
9947
+ class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher
9948
+ end
9949
+
9950
+ class RSpec::Matchers::BuiltIn::RaiseError
9951
+ include ::RSpec::Matchers::Composable
9952
+ def description(); end
9953
+
9954
+ def does_not_match?(given_proc); end
9955
+
9956
+ def expects_call_stack_jump?(); end
9957
+
9958
+ def failure_message(); end
9959
+
9960
+ def failure_message_when_negated(); end
9961
+
9962
+ def initialize(expected_error_or_message=T.unsafe(nil), expected_message=T.unsafe(nil), &block); end
9963
+
9964
+ def matches?(given_proc, negative_expectation=T.unsafe(nil), &block); end
9965
+
9966
+ def supports_block_expectations?(); end
9967
+
9968
+ def with_message(expected_message); end
9969
+ end
9970
+
9971
+ class RSpec::Matchers::BuiltIn::RaiseError
9972
+ end
9973
+
9974
+ class RSpec::Matchers::BuiltIn::RespondTo
9975
+ def and_any_keywords(); end
9976
+
9977
+ def and_keywords(*keywords); end
9978
+
9979
+ def and_unlimited_arguments(); end
9980
+
9981
+ def argument(); end
9982
+
9983
+ def arguments(); end
9984
+
9985
+ def does_not_match?(actual); end
9986
+
9987
+ def initialize(*names); end
9988
+
9989
+ def with(n); end
9990
+
9991
+ def with_any_keywords(); end
9992
+
9993
+ def with_keywords(*keywords); end
9994
+
9995
+ def with_unlimited_arguments(); end
9996
+ end
9997
+
9998
+ class RSpec::Matchers::BuiltIn::RespondTo
9999
+ end
10000
+
10001
+ class RSpec::Matchers::BuiltIn::Satisfy
10002
+ def initialize(description=T.unsafe(nil), &block); end
10003
+
10004
+ def matches?(actual, &block); end
10005
+ end
10006
+
10007
+ class RSpec::Matchers::BuiltIn::Satisfy
10008
+ end
10009
+
10010
+ class RSpec::Matchers::BuiltIn::StartOrEndWith
10011
+ def initialize(*expected); end
10012
+ end
10013
+
10014
+ class RSpec::Matchers::BuiltIn::StartOrEndWith
10015
+ end
10016
+
10017
+ class RSpec::Matchers::BuiltIn::StartWith
10018
+ end
10019
+
10020
+ class RSpec::Matchers::BuiltIn::StartWith
10021
+ end
10022
+
10023
+ class RSpec::Matchers::BuiltIn::ThrowSymbol
10024
+ include ::RSpec::Matchers::Composable
10025
+ def description(); end
10026
+
10027
+ def does_not_match?(given_proc); end
10028
+
10029
+ def expects_call_stack_jump?(); end
10030
+
10031
+ def failure_message(); end
10032
+
10033
+ def failure_message_when_negated(); end
10034
+
10035
+ def initialize(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end
10036
+
10037
+ def matches?(given_proc); end
10038
+
10039
+ def supports_block_expectations?(); end
10040
+ end
10041
+
10042
+ class RSpec::Matchers::BuiltIn::ThrowSymbol
10043
+ end
10044
+
10045
+ class RSpec::Matchers::BuiltIn::YieldControl
10046
+ def at_least(number); end
10047
+
10048
+ def at_most(number); end
10049
+
10050
+ def does_not_match?(block); end
10051
+
10052
+ def exactly(number); end
10053
+
10054
+ def initialize(); end
10055
+
10056
+ def matches?(block); end
10057
+
10058
+ def once(); end
10059
+
10060
+ def thrice(); end
10061
+
10062
+ def times(); end
10063
+
10064
+ def twice(); end
10065
+ end
10066
+
10067
+ class RSpec::Matchers::BuiltIn::YieldControl
8350
10068
  end
8351
10069
 
8352
- module RSpec::Core::DSL
8353
- extend ::T::Sig
10070
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs
10071
+ def does_not_match?(block); end
10072
+
10073
+ def initialize(*args); end
10074
+
10075
+ def matches?(block); end
8354
10076
  end
8355
10077
 
8356
- RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
10078
+ class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs
10079
+ end
8357
10080
 
8358
- class RSpec::Core::ExampleGroup
8359
- INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
10081
+ class RSpec::Matchers::BuiltIn::YieldWithArgs
10082
+ def does_not_match?(block); end
10083
+
10084
+ def initialize(*args); end
10085
+
10086
+ def matches?(block); end
8360
10087
  end
8361
10088
 
8362
- class RSpec::Core::ExampleStatusPersister
8363
- def initialize(examples, file_name); end
10089
+ class RSpec::Matchers::BuiltIn::YieldWithArgs
10090
+ end
8364
10091
 
8365
- def persist(); end
10092
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs
10093
+ def does_not_match?(block); end
10094
+
10095
+ def matches?(block); end
8366
10096
  end
8367
10097
 
8368
- class RSpec::Core::ExampleStatusPersister
8369
- def self.load_from(file_name); end
10098
+ class RSpec::Matchers::BuiltIn::YieldWithNoArgs
10099
+ end
8370
10100
 
8371
- def self.persist(examples, file_name); end
10101
+ module RSpec::Matchers::BuiltIn
10102
+ extend ::T::Sig
8372
10103
  end
8373
10104
 
8374
- RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
10105
+ module RSpec::Matchers::Composable
10106
+ extend ::T::Sig
10107
+ end
8375
10108
 
8376
- class RSpec::Core::FilterRules
8377
- PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
8378
- PROJECT_DIR = ::T.let(nil, ::T.untyped)
10109
+ module RSpec::Matchers::DSL::DefaultImplementations
10110
+ extend ::T::Sig
8379
10111
  end
8380
10112
 
8381
- module RSpec::Core::FilterableItemRepository
10113
+ module RSpec::Matchers::DSL::Macros
10114
+ RAISE_NOTIFIER = ::T.let(nil, ::T.untyped)
10115
+ end
10116
+
10117
+ module RSpec::Matchers::DSL::Macros::Deprecated
8382
10118
  extend ::T::Sig
8383
10119
  end
8384
10120
 
8385
- module RSpec::Core::FlatMap
10121
+ module RSpec::Matchers::DSL::Macros
8386
10122
  extend ::T::Sig
8387
10123
  end
8388
10124
 
8389
- class RSpec::Core::Formatters::BaseBisectFormatter
8390
- def example_failed(notification); end
10125
+ module RSpec::Matchers::DSL
10126
+ extend ::T::Sig
10127
+ end
8391
10128
 
8392
- def example_finished(notification); end
10129
+ module RSpec::Matchers::EnglishPhrasing
10130
+ extend ::T::Sig
10131
+ end
8393
10132
 
8394
- def initialize(expected_failures); end
10133
+ class RSpec::Matchers::ExpectedsForMultipleDiffs
10134
+ DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped)
10135
+ DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped)
10136
+ end
8395
10137
 
8396
- def start_dump(_notification); end
10138
+ module RSpec::Matchers
10139
+ extend ::T::Sig
8397
10140
  end
8398
10141
 
8399
- class RSpec::Core::Formatters::BaseBisectFormatter
8400
- def self.inherited(formatter); end
10142
+ module RSpec::Mocks
10143
+ DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped)
10144
+ IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped)
8401
10145
  end
8402
10146
 
8403
- class RSpec::Core::Formatters::BaseFormatter
8404
- def close(_notification); end
10147
+ module RSpec::Mocks::AnyInstance
10148
+ end
8405
10149
 
8406
- def example_group(); end
10150
+ class RSpec::Mocks::AnyInstance::Chain
10151
+ include ::RSpec::Mocks::AnyInstance::Chain::Customizations
10152
+ def constrained_to_any_of?(*constraints); end
8407
10153
 
8408
- def example_group=(example_group); end
10154
+ def expectation_fulfilled!(); end
8409
10155
 
8410
- def example_group_started(notification); end
10156
+ def initialize(recorder, *args, &block); end
8411
10157
 
8412
- def initialize(output); end
10158
+ def matches_args?(*args); end
8413
10159
 
8414
- def output(); end
10160
+ def never(); end
8415
10161
 
8416
- def start(notification); end
10162
+ def playback!(instance); end
8417
10163
  end
8418
10164
 
8419
- class RSpec::Core::Formatters::BaseFormatter
8420
- end
10165
+ module RSpec::Mocks::AnyInstance::Chain::Customizations
10166
+ def and_call_original(*args, &block); end
8421
10167
 
8422
- class RSpec::Core::Formatters::BaseTextFormatter
8423
- def dump_failures(notification); end
10168
+ def and_raise(*args, &block); end
8424
10169
 
8425
- def dump_pending(notification); end
10170
+ def and_return(*args, &block); end
8426
10171
 
8427
- def dump_summary(summary); end
10172
+ def and_throw(*args, &block); end
8428
10173
 
8429
- def message(notification); end
10174
+ def and_wrap_original(*args, &block); end
8430
10175
 
8431
- def seed(notification); end
8432
- end
10176
+ def and_yield(*args, &block); end
8433
10177
 
8434
- class RSpec::Core::Formatters::BaseTextFormatter
8435
- end
10178
+ def at_least(*args, &block); end
8436
10179
 
8437
- class RSpec::Core::Formatters::BisectDRbFormatter
8438
- def initialize(_output); end
10180
+ def at_most(*args, &block); end
8439
10181
 
8440
- def notify_results(results); end
8441
- end
10182
+ def exactly(*args, &block); end
8442
10183
 
8443
- class RSpec::Core::Formatters::BisectDRbFormatter
8444
- end
10184
+ def never(*args, &block); end
8445
10185
 
8446
- module RSpec::Core::Formatters::ConsoleCodes
8447
- VT100_CODES = ::T.let(nil, ::T.untyped)
8448
- VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
10186
+ def once(*args, &block); end
10187
+
10188
+ def thrice(*args, &block); end
10189
+
10190
+ def times(*args, &block); end
10191
+
10192
+ def twice(*args, &block); end
10193
+
10194
+ def with(*args, &block); end
8449
10195
  end
8450
10196
 
8451
- module RSpec::Core::Formatters::ConsoleCodes
10197
+ module RSpec::Mocks::AnyInstance::Chain::Customizations
8452
10198
  extend ::T::Sig
10199
+ def self.record(method_name); end
8453
10200
  end
8454
10201
 
8455
- class RSpec::Core::Formatters::DeprecationFormatter
8456
- DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
8457
- RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
8458
- TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
10202
+ class RSpec::Mocks::AnyInstance::Chain
8459
10203
  end
8460
10204
 
8461
- class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
8462
- TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
10205
+ class RSpec::Mocks::AnyInstance::ErrorGenerator
10206
+ def raise_does_not_implement_error(klass, method_name); end
10207
+
10208
+ def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
10209
+
10210
+ def raise_not_supported_with_prepend_error(method_name, problem_mod); end
10211
+
10212
+ def raise_second_instance_received_message_error(unfulfilled_expectations); end
8463
10213
  end
8464
10214
 
8465
- class RSpec::Core::Formatters::DocumentationFormatter
8466
- def example_failed(failure); end
10215
+ class RSpec::Mocks::AnyInstance::ErrorGenerator
10216
+ end
8467
10217
 
8468
- def example_group_finished(_notification); end
10218
+ class RSpec::Mocks::AnyInstance::ExpectChainChain
10219
+ def initialize(*args); end
10220
+ end
8469
10221
 
8470
- def example_passed(passed); end
10222
+ class RSpec::Mocks::AnyInstance::ExpectChainChain
10223
+ end
8471
10224
 
8472
- def example_pending(pending); end
10225
+ class RSpec::Mocks::AnyInstance::ExpectationChain
10226
+ def expectation_fulfilled?(); end
10227
+
10228
+ def initialize(*args, &block); end
8473
10229
  end
8474
10230
 
8475
- class RSpec::Core::Formatters::DocumentationFormatter
10231
+ class RSpec::Mocks::AnyInstance::ExpectationChain
8476
10232
  end
8477
10233
 
8478
- class RSpec::Core::Formatters::ExceptionPresenter
8479
- PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
10234
+ class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
10235
+ def initialize(targets); end
10236
+
10237
+ def method_missing(*args, &block); end
8480
10238
  end
8481
10239
 
8482
- module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
8483
- extend ::T::Sig
10240
+ class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
8484
10241
  end
8485
10242
 
8486
- class RSpec::Core::Formatters::FallbackMessageFormatter
8487
- def initialize(output); end
10243
+ class RSpec::Mocks::AnyInstance::MessageChains
10244
+ def [](method_name); end
8488
10245
 
8489
- def message(notification); end
10246
+ def add(method_name, chain); end
8490
10247
 
8491
- def output(); end
10248
+ def all_expectations_fulfilled?(); end
10249
+
10250
+ def each_unfulfilled_expectation_matching(method_name, *args); end
10251
+
10252
+ def has_expectation?(method_name); end
10253
+
10254
+ def playback!(instance, method_name); end
10255
+
10256
+ def received_expected_message!(method_name); end
10257
+
10258
+ def remove_stub_chains_for!(method_name); end
10259
+
10260
+ def unfulfilled_expectations(); end
8492
10261
  end
8493
10262
 
8494
- class RSpec::Core::Formatters::FallbackMessageFormatter
10263
+ class RSpec::Mocks::AnyInstance::MessageChains
8495
10264
  end
8496
10265
 
8497
- module RSpec::Core::Formatters::Helpers
8498
- DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
8499
- SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
10266
+ class RSpec::Mocks::AnyInstance::PositiveExpectationChain
10267
+ ExpectationInvocationOrder = ::T.let(nil, ::T.untyped)
8500
10268
  end
8501
10269
 
8502
- module RSpec::Core::Formatters::Helpers
8503
- extend ::T::Sig
10270
+ class RSpec::Mocks::AnyInstance::PositiveExpectationChain
8504
10271
  end
8505
10272
 
8506
- class RSpec::Core::Formatters::HtmlFormatter
8507
- def dump_summary(summary); end
10273
+ class RSpec::Mocks::AnyInstance::Proxy
10274
+ def expect_chain(*chain, &block); end
8508
10275
 
8509
- def example_failed(failure); end
10276
+ def initialize(recorder, target_proxies); end
8510
10277
 
8511
- def example_passed(passed); end
10278
+ def klass(); end
8512
10279
 
8513
- def example_pending(pending); end
10280
+ def should_not_receive(method_name, &block); end
8514
10281
 
8515
- def example_started(_notification); end
10282
+ def should_receive(method_name, &block); end
8516
10283
 
8517
- def start_dump(_notification); end
10284
+ def stub(method_name_or_method_map, &block); end
10285
+
10286
+ def stub_chain(*chain, &block); end
10287
+
10288
+ def unstub(method_name); end
8518
10289
  end
8519
10290
 
8520
- class RSpec::Core::Formatters::HtmlFormatter
10291
+ class RSpec::Mocks::AnyInstance::Proxy
8521
10292
  end
8522
10293
 
8523
- class RSpec::Core::Formatters::JsonFormatter
8524
- def dump_profile(profile); end
10294
+ class RSpec::Mocks::AnyInstance::Recorder
10295
+ def already_observing?(method_name); end
8525
10296
 
8526
- def dump_profile_slowest_example_groups(profile); end
10297
+ def build_alias_method_name(method_name); end
8527
10298
 
8528
- def dump_profile_slowest_examples(profile); end
10299
+ def expect_chain(*method_names_and_optional_return_values, &block); end
8529
10300
 
8530
- def dump_summary(summary); end
10301
+ def initialize(klass); end
8531
10302
 
8532
- def message(notification); end
10303
+ def instance_that_received(method_name); end
8533
10304
 
8534
- def output_hash(); end
10305
+ def klass(); end
8535
10306
 
8536
- def seed(notification); end
10307
+ def message_chains(); end
8537
10308
 
8538
- def stop(notification); end
8539
- end
10309
+ def notify_received_message(_object, message, args, _blk); end
8540
10310
 
8541
- class RSpec::Core::Formatters::JsonFormatter
8542
- end
10311
+ def playback!(instance, method_name); end
8543
10312
 
8544
- class RSpec::Core::Formatters::ProfileFormatter
8545
- def dump_profile(profile); end
10313
+ def should_not_receive(method_name, &block); end
8546
10314
 
8547
- def initialize(output); end
10315
+ def should_receive(method_name, &block); end
8548
10316
 
8549
- def output(); end
8550
- end
10317
+ def stop_all_observation!(); end
8551
10318
 
8552
- class RSpec::Core::Formatters::ProfileFormatter
8553
- end
10319
+ def stop_observing!(method_name); end
8554
10320
 
8555
- class RSpec::Core::Formatters::ProgressFormatter
8556
- def example_failed(_notification); end
10321
+ def stub(method_name, &block); end
8557
10322
 
8558
- def example_passed(_notification); end
10323
+ def stub_chain(*method_names_and_optional_return_values, &block); end
8559
10324
 
8560
- def example_pending(_notification); end
10325
+ def stubs(); end
8561
10326
 
8562
- def start_dump(_notification); end
10327
+ def unstub(method_name); end
10328
+
10329
+ def verify(); end
8563
10330
  end
8564
10331
 
8565
- class RSpec::Core::Formatters::ProgressFormatter
10332
+ class RSpec::Mocks::AnyInstance::Recorder
8566
10333
  end
8567
10334
 
8568
- module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
8569
- RESET_CODE = ::T.let(nil, ::T.untyped)
10335
+ class RSpec::Mocks::AnyInstance::StubChain
10336
+ def expectation_fulfilled?(); end
10337
+ EmptyInvocationOrder = ::T.let(nil, ::T.untyped)
10338
+ InvocationOrder = ::T.let(nil, ::T.untyped)
8570
10339
  end
8571
10340
 
8572
- module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
8573
- extend ::T::Sig
10341
+ class RSpec::Mocks::AnyInstance::StubChain
8574
10342
  end
8575
10343
 
8576
- module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
10344
+ class RSpec::Mocks::AnyInstance::StubChainChain
10345
+ def initialize(*args); end
10346
+ end
10347
+
10348
+ class RSpec::Mocks::AnyInstance::StubChainChain
10349
+ end
10350
+
10351
+ module RSpec::Mocks::AnyInstance
8577
10352
  extend ::T::Sig
10353
+ def self.error_generator(); end
8578
10354
  end
8579
10355
 
8580
- RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
10356
+ class RSpec::Mocks::ArgumentListMatcher
10357
+ MATCH_ALL = ::T.let(nil, ::T.untyped)
10358
+ end
8581
10359
 
8582
- module RSpec::Core::Formatters
10360
+ module RSpec::Mocks::ArgumentMatchers
8583
10361
  extend ::T::Sig
8584
10362
  end
8585
10363
 
8586
- module RSpec::Core::HashImitatable::ClassMethods
10364
+ module RSpec::Mocks::ExampleMethods::ExpectHost
8587
10365
  extend ::T::Sig
8588
10366
  end
8589
10367
 
8590
- module RSpec::Core::HashImitatable
10368
+ module RSpec::Mocks::ExampleMethods
8591
10369
  extend ::T::Sig
8592
10370
  end
8593
10371
 
8594
- class RSpec::Core::Hooks::HookCollections
8595
- EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
8596
- HOOK_TYPES = ::T.let(nil, ::T.untyped)
8597
- SCOPES = ::T.let(nil, ::T.untyped)
8598
- SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
10372
+ class RSpec::Mocks::ExpectChain
8599
10373
  end
8600
10374
 
8601
- module RSpec::Core::Hooks
8602
- extend ::T::Sig
10375
+ class RSpec::Mocks::ExpectChain
10376
+ def self.expect_chain_on(object, *chain, &blk); end
8603
10377
  end
8604
10378
 
8605
- module RSpec::Core::Invocations
10379
+ module RSpec::Mocks::ExpectationTargetMethods
8606
10380
  extend ::T::Sig
8607
10381
  end
8608
10382
 
8609
- module RSpec::Core::MemoizedHelpers::ClassMethods
10383
+ class RSpec::Mocks::MarshalExtension
10384
+ end
10385
+
10386
+ class RSpec::Mocks::MarshalExtension
10387
+ def self.patch!(); end
10388
+
10389
+ def self.unpatch!(); end
10390
+ end
10391
+
10392
+ class RSpec::Mocks::Matchers::HaveReceived
10393
+ include ::RSpec::Mocks::Matchers::Matcher
10394
+ def at_least(*args); end
10395
+
10396
+ def at_most(*args); end
10397
+
10398
+ def description(); end
10399
+
10400
+ def does_not_match?(subject); end
10401
+
10402
+ def exactly(*args); end
10403
+
10404
+ def failure_message(); end
10405
+
10406
+ def failure_message_when_negated(); end
10407
+
10408
+ def initialize(method_name, &block); end
10409
+
10410
+ def matches?(subject, &block); end
10411
+
10412
+ def name(); end
10413
+
10414
+ def once(*args); end
10415
+
10416
+ def ordered(*args); end
10417
+
10418
+ def setup_allowance(_subject, &_block); end
10419
+
10420
+ def setup_any_instance_allowance(_subject, &_block); end
10421
+
10422
+ def setup_any_instance_expectation(_subject, &_block); end
10423
+
10424
+ def setup_any_instance_negative_expectation(_subject, &_block); end
10425
+
10426
+ def setup_expectation(subject, &block); end
10427
+
10428
+ def setup_negative_expectation(subject, &block); end
10429
+
10430
+ def thrice(*args); end
10431
+
10432
+ def times(*args); end
10433
+
10434
+ def twice(*args); end
10435
+
10436
+ def with(*args); end
10437
+ ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped)
10438
+ CONSTRAINTS = ::T.let(nil, ::T.untyped)
10439
+ COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped)
10440
+ end
10441
+
10442
+ class RSpec::Mocks::Matchers::HaveReceived
10443
+ end
10444
+
10445
+ module RSpec::Mocks::Matchers::Matcher
8610
10446
  extend ::T::Sig
8611
10447
  end
8612
10448
 
8613
- module RSpec::Core::MemoizedHelpers
8614
- extend ::T::Sig
8615
- end
10449
+ class RSpec::Mocks::Matchers::Receive
10450
+ include ::RSpec::Mocks::Matchers::Matcher
10451
+ def and_call_original(*args, &block); end
10452
+
10453
+ def and_raise(*args, &block); end
10454
+
10455
+ def and_return(*args, &block); end
10456
+
10457
+ def and_throw(*args, &block); end
10458
+
10459
+ def and_wrap_original(*args, &block); end
10460
+
10461
+ def and_yield(*args, &block); end
10462
+
10463
+ def at_least(*args, &block); end
10464
+
10465
+ def at_most(*args, &block); end
10466
+
10467
+ def description(); end
10468
+
10469
+ def does_not_match?(subject, &block); end
10470
+
10471
+ def exactly(*args, &block); end
10472
+
10473
+ def initialize(message, block); end
10474
+
10475
+ def matches?(subject, &block); end
10476
+
10477
+ def name(); end
10478
+
10479
+ def never(*args, &block); end
10480
+
10481
+ def once(*args, &block); end
10482
+
10483
+ def ordered(*args, &block); end
10484
+
10485
+ def setup_allowance(subject, &block); end
10486
+
10487
+ def setup_any_instance_allowance(subject, &block); end
10488
+
10489
+ def setup_any_instance_expectation(subject, &block); end
10490
+
10491
+ def setup_any_instance_negative_expectation(subject, &block); end
10492
+
10493
+ def setup_expectation(subject, &block); end
10494
+
10495
+ def setup_negative_expectation(subject, &block); end
10496
+
10497
+ def thrice(*args, &block); end
10498
+
10499
+ def times(*args, &block); end
10500
+
10501
+ def twice(*args, &block); end
8616
10502
 
8617
- module RSpec::Core::Metadata
8618
- RESERVED_KEYS = ::T.let(nil, ::T.untyped)
10503
+ def with(*args, &block); end
8619
10504
  end
8620
10505
 
8621
- module RSpec::Core::Metadata
8622
- extend ::T::Sig
8623
- end
10506
+ class RSpec::Mocks::Matchers::Receive::DefaultDescribable
10507
+ def description_for(verb); end
8624
10508
 
8625
- module RSpec::Core::MetadataFilter
8626
- extend ::T::Sig
10509
+ def initialize(message); end
8627
10510
  end
8628
10511
 
8629
- module RSpec::Core::MultipleExceptionError::InterfaceTag
8630
- extend ::T::Sig
10512
+ class RSpec::Mocks::Matchers::Receive::DefaultDescribable
8631
10513
  end
8632
10514
 
8633
- module RSpec::Core::Notifications::NullColorizer
8634
- extend ::T::Sig
10515
+ class RSpec::Mocks::Matchers::Receive
8635
10516
  end
8636
10517
 
8637
- module RSpec::Core::Notifications
8638
- extend ::T::Sig
8639
- end
10518
+ class RSpec::Mocks::Matchers::ReceiveMessageChain
10519
+ include ::RSpec::Mocks::Matchers::Matcher
10520
+ def and_call_original(*args, &block); end
8640
10521
 
8641
- class RSpec::Core::Ordering::Random
8642
- MAX_32_BIT = ::T.let(nil, ::T.untyped)
8643
- end
10522
+ def and_raise(*args, &block); end
8644
10523
 
8645
- module RSpec::Core::Ordering
8646
- extend ::T::Sig
8647
- end
10524
+ def and_return(*args, &block); end
8648
10525
 
8649
- module RSpec::Core::Pending
8650
- NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
8651
- NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
8652
- end
10526
+ def and_throw(*args, &block); end
8653
10527
 
8654
- module RSpec::Core::Pending
8655
- extend ::T::Sig
8656
- end
10528
+ def and_yield(*args, &block); end
8657
10529
 
8658
- class RSpec::Core::Profiler
8659
- def example_group_finished(notification); end
10530
+ def description(); end
8660
10531
 
8661
- def example_group_started(notification); end
10532
+ def does_not_match?(*_args); end
8662
10533
 
8663
- def example_groups(); end
10534
+ def initialize(chain, &block); end
8664
10535
 
8665
- def example_started(notification); end
8666
- NOTIFICATIONS = ::T.let(nil, ::T.untyped)
8667
- end
10536
+ def matches?(subject, &block); end
8668
10537
 
8669
- class RSpec::Core::Profiler
8670
- end
10538
+ def name(); end
8671
10539
 
8672
- class RSpec::Core::Reporter
8673
- RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
8674
- end
10540
+ def setup_allowance(subject, &block); end
8675
10541
 
8676
- module RSpec::Core::RubyProject
8677
- extend ::T::Sig
8678
- end
10542
+ def setup_any_instance_allowance(subject, &block); end
8679
10543
 
8680
- module RSpec::Core::SharedContext
8681
- def __shared_context_recordings(); end
10544
+ def setup_any_instance_expectation(subject, &block); end
8682
10545
 
8683
- def after(*args, &block); end
10546
+ def setup_expectation(subject, &block); end
8684
10547
 
8685
- def append_after(*args, &block); end
10548
+ def setup_negative_expectation(*_args); end
8686
10549
 
8687
- def append_before(*args, &block); end
10550
+ def with(*args, &block); end
10551
+ end
8688
10552
 
8689
- def around(*args, &block); end
10553
+ class RSpec::Mocks::Matchers::ReceiveMessageChain
10554
+ end
8690
10555
 
8691
- def before(*args, &block); end
10556
+ class RSpec::Mocks::Matchers::ReceiveMessages
10557
+ include ::RSpec::Mocks::Matchers::Matcher
10558
+ def description(); end
8692
10559
 
8693
- def context(*args, &block); end
10560
+ def does_not_match?(_subject); end
8694
10561
 
8695
- def describe(*args, &block); end
10562
+ def initialize(message_return_value_hash); end
8696
10563
 
8697
- def hooks(*args, &block); end
10564
+ def matches?(subject); end
8698
10565
 
8699
- def included(group); end
10566
+ def name(); end
8700
10567
 
8701
- def let(*args, &block); end
10568
+ def setup_allowance(subject); end
8702
10569
 
8703
- def let!(*args, &block); end
10570
+ def setup_any_instance_allowance(subject); end
8704
10571
 
8705
- def prepend_after(*args, &block); end
10572
+ def setup_any_instance_expectation(subject); end
8706
10573
 
8707
- def prepend_before(*args, &block); end
10574
+ def setup_expectation(subject); end
8708
10575
 
8709
- def subject(*args, &block); end
10576
+ def setup_negative_expectation(_subject); end
8710
10577
 
8711
- def subject!(*args, &block); end
10578
+ def warn_about_block(); end
8712
10579
  end
8713
10580
 
8714
- class RSpec::Core::SharedContext::Recording
8715
- def args(); end
10581
+ class RSpec::Mocks::Matchers::ReceiveMessages
10582
+ end
8716
10583
 
8717
- def args=(_); end
10584
+ module RSpec::Mocks::Matchers
10585
+ extend ::T::Sig
10586
+ end
8718
10587
 
10588
+ class RSpec::Mocks::MessageChain
8719
10589
  def block(); end
8720
10590
 
8721
- def block=(_); end
10591
+ def chain(); end
8722
10592
 
8723
- def method_name(); end
10593
+ def initialize(object, *chain, &blk); end
8724
10594
 
8725
- def method_name=(_); end
10595
+ def object(); end
8726
10596
 
8727
- def playback_onto(group); end
10597
+ def setup_chain(); end
8728
10598
  end
8729
10599
 
8730
- class RSpec::Core::SharedContext::Recording
8731
- def self.[](*_); end
10600
+ class RSpec::Mocks::MessageChain
10601
+ end
8732
10602
 
8733
- def self.members(); end
10603
+ module RSpec::Mocks::MessageExpectation::ImplementationDetails
10604
+ extend ::T::Sig
8734
10605
  end
8735
10606
 
8736
- module RSpec::Core::SharedContext
10607
+ class RSpec::Mocks::ObjectReference
10608
+ MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped)
10609
+ end
10610
+
10611
+ module RSpec::Mocks::ObjectVerifyingDoubleMethods
8737
10612
  extend ::T::Sig
8738
- def self.record(methods); end
8739
10613
  end
8740
10614
 
8741
- module RSpec::Core::SharedExampleGroup::TopLevelDSL
10615
+ module RSpec::Mocks::PartialClassDoubleProxyMethods
8742
10616
  extend ::T::Sig
8743
10617
  end
8744
10618
 
8745
- module RSpec::Core::SharedExampleGroup
10619
+ class RSpec::Mocks::Proxy
10620
+ DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped)
10621
+ end
10622
+
10623
+ class RSpec::Mocks::StubChain
10624
+ end
10625
+
10626
+ class RSpec::Mocks::StubChain
10627
+ def self.stub_chain_on(object, *chain, &blk); end
10628
+ end
10629
+
10630
+ module RSpec::Mocks::Syntax
8746
10631
  extend ::T::Sig
8747
10632
  end
8748
10633
 
8749
- module RSpec::Core::ShellEscape
8750
- SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
10634
+ module RSpec::Mocks::TargetDelegationClassMethods
10635
+ extend ::T::Sig
8751
10636
  end
8752
10637
 
8753
- module RSpec::Core::ShellEscape
10638
+ module RSpec::Mocks::TargetDelegationInstanceMethods
8754
10639
  extend ::T::Sig
8755
10640
  end
8756
10641
 
8757
- module RSpec::Core::Version
8758
- STRING = ::T.let(nil, ::T.untyped)
10642
+ module RSpec::Mocks::TestDouble
10643
+ extend ::T::Sig
8759
10644
  end
8760
10645
 
8761
- module RSpec::Core::Version
10646
+ module RSpec::Mocks::TestDoubleFormatter
8762
10647
  extend ::T::Sig
8763
10648
  end
8764
10649
 
8765
- module RSpec::Core::Warnings
10650
+ module RSpec::Mocks::VerifyingDouble::SilentIO
8766
10651
  extend ::T::Sig
8767
10652
  end
8768
10653
 
8769
- module RSpec::Core::World::Null
10654
+ module RSpec::Mocks::VerifyingDouble
8770
10655
  extend ::T::Sig
8771
10656
  end
8772
10657
 
8773
- module RSpec::Core
10658
+ module RSpec::Mocks::VerifyingProxyMethods
8774
10659
  extend ::T::Sig
8775
10660
  end
8776
10661
 
8777
- module RSpec::ExampleGroups
10662
+ module RSpec::Mocks::Version
10663
+ STRING = ::T.let(nil, ::T.untyped)
10664
+ end
10665
+
10666
+ module RSpec::Mocks::Version
10667
+ extend ::T::Sig
10668
+ end
10669
+
10670
+ module RSpec::Mocks
8778
10671
  extend ::T::Sig
8779
10672
  end
8780
10673
 
@@ -8817,12 +10710,37 @@ class RSpec::Support::EncodedString
8817
10710
  UTF_8 = ::T.let(nil, ::T.untyped)
8818
10711
  end
8819
10712
 
10713
+ module RSpec::Support::FuzzyMatcher
10714
+ extend ::T::Sig
10715
+ end
10716
+
10717
+ class RSpec::Support::MethodSignature
10718
+ INFINITY = ::T.let(nil, ::T.untyped)
10719
+ end
10720
+
8820
10721
  RSpec::Support::Mutex = Thread::Mutex
8821
10722
 
8822
10723
  module RSpec::Support::OS
8823
10724
  extend ::T::Sig
8824
10725
  end
8825
10726
 
10727
+ class RSpec::Support::ObjectFormatter
10728
+ ELLIPSIS = ::T.let(nil, ::T.untyped)
10729
+ INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped)
10730
+ end
10731
+
10732
+ class RSpec::Support::ObjectFormatter::DateTimeInspector
10733
+ FORMAT = ::T.let(nil, ::T.untyped)
10734
+ end
10735
+
10736
+ class RSpec::Support::ObjectFormatter::TimeInspector
10737
+ FORMAT = ::T.let(nil, ::T.untyped)
10738
+ end
10739
+
10740
+ class RSpec::Support::ObjectFormatter::UninspectableObjectInspector
10741
+ OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped)
10742
+ end
10743
+
8826
10744
  module RSpec::Support::RecursiveConstMethods
8827
10745
  extend ::T::Sig
8828
10746
  end
@@ -8835,6 +10753,8 @@ module RSpec::Support::RubyFeatures
8835
10753
  extend ::T::Sig
8836
10754
  end
8837
10755
 
10756
+ RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
10757
+
8838
10758
  module RSpec::Support::Version
8839
10759
  STRING = ::T.let(nil, ::T.untyped)
8840
10760
  end
@@ -8849,15 +10769,6 @@ end
8849
10769
 
8850
10770
  module RSpec::Support
8851
10771
  extend ::T::Sig
8852
- def self.deregister_matcher_definition(&block); end
8853
-
8854
- def self.is_a_matcher?(object); end
8855
-
8856
- def self.matcher_definitions(); end
8857
-
8858
- def self.register_matcher_definition(&block); end
8859
-
8860
- def self.rspec_description_for_object(object); end
8861
10772
  end
8862
10773
 
8863
10774
  module RSpec::Version
@@ -9019,9 +10930,20 @@ end
9019
10930
 
9020
10931
  class Random
9021
10932
  extend ::T::Sig
10933
+ extend ::Random::Formatter
10934
+ def self.bytes(_); end
10935
+
9022
10936
  def self.urandom(_); end
9023
10937
  end
9024
10938
 
10939
+ class Range
10940
+ def %(_); end
10941
+
10942
+ def entries(); end
10943
+
10944
+ def to_a(); end
10945
+ end
10946
+
9025
10947
  class Range
9026
10948
  extend ::T::Sig
9027
10949
  end
@@ -9038,6 +10960,8 @@ module RbConfig
9038
10960
  extend ::T::Sig
9039
10961
  def self.expand(val, config=T.unsafe(nil)); end
9040
10962
 
10963
+ def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
10964
+
9041
10965
  def self.ruby(); end
9042
10966
  end
9043
10967
 
@@ -9054,6 +10978,37 @@ class RegexpError
9054
10978
  extend ::T::Sig
9055
10979
  end
9056
10980
 
10981
+ module RubyVM::AbstractSyntaxTree
10982
+ end
10983
+
10984
+ class RubyVM::AbstractSyntaxTree::Node
10985
+ def children(); end
10986
+
10987
+ def first_column(); end
10988
+
10989
+ def first_lineno(); end
10990
+
10991
+ def last_column(); end
10992
+
10993
+ def last_lineno(); end
10994
+
10995
+ def pretty_print_children(q, names=T.unsafe(nil)); end
10996
+
10997
+ def type(); end
10998
+ end
10999
+
11000
+ class RubyVM::AbstractSyntaxTree::Node
11001
+ end
11002
+
11003
+ module RubyVM::AbstractSyntaxTree
11004
+ extend ::T::Sig
11005
+ def self.of(_); end
11006
+
11007
+ def self.parse(_); end
11008
+
11009
+ def self.parse_file(_); end
11010
+ end
11011
+
9057
11012
  class RubyVM::InstructionSequence
9058
11013
  def absolute_path(); end
9059
11014
 
@@ -9101,8 +11056,22 @@ class RubyVM::InstructionSequence
9101
11056
  def self.of(_); end
9102
11057
  end
9103
11058
 
11059
+ module RubyVM::MJIT
11060
+ end
11061
+
11062
+ module RubyVM::MJIT
11063
+ extend ::T::Sig
11064
+ def self.enabled?(); end
11065
+
11066
+ def self.pause(*_); end
11067
+
11068
+ def self.resume(); end
11069
+ end
11070
+
9104
11071
  class RubyVM
9105
11072
  extend ::T::Sig
11073
+ def self.resolve_feature_path(_); end
11074
+
9106
11075
  def self.stat(*_); end
9107
11076
  end
9108
11077
 
@@ -9133,6 +11102,8 @@ class Set
9133
11102
 
9134
11103
  def eql?(o); end
9135
11104
 
11105
+ def filter!(&block); end
11106
+
9136
11107
  def flatten_merge(set, seen=T.unsafe(nil)); end
9137
11108
 
9138
11109
  def pretty_print(pp); end
@@ -9181,10 +11152,87 @@ class SignalException
9181
11152
  extend ::T::Sig
9182
11153
  end
9183
11154
 
11155
+ module SimpleCov
11156
+ VERSION = ::T.let(nil, ::T.untyped)
11157
+ end
11158
+
11159
+ module SimpleCov::CommandGuesser
11160
+ extend ::T::Sig
11161
+ end
11162
+
11163
+ module SimpleCov::Configuration
11164
+ extend ::T::Sig
11165
+ end
11166
+
11167
+ module SimpleCov::ExitCodes
11168
+ EXCEPTION = ::T.let(nil, ::T.untyped)
11169
+ MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped)
11170
+ MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped)
11171
+ SUCCESS = ::T.let(nil, ::T.untyped)
11172
+ end
11173
+
11174
+ module SimpleCov::ExitCodes
11175
+ extend ::T::Sig
11176
+ end
11177
+
11178
+ class SimpleCov::Formatter::HTMLFormatter
11179
+ VERSION = ::T.let(nil, ::T.untyped)
11180
+ end
11181
+
11182
+ module SimpleCov::Formatter::MultiFormatter::InstanceMethods
11183
+ extend ::T::Sig
11184
+ end
11185
+
11186
+ module SimpleCov::Formatter
11187
+ extend ::T::Sig
11188
+ end
11189
+
11190
+ module SimpleCov::LastRun
11191
+ extend ::T::Sig
11192
+ end
11193
+
11194
+ class SimpleCov::LinesClassifier
11195
+ COMMENT_LINE = ::T.let(nil, ::T.untyped)
11196
+ NOT_RELEVANT = ::T.let(nil, ::T.untyped)
11197
+ RELEVANT = ::T.let(nil, ::T.untyped)
11198
+ WHITESPACE_LINE = ::T.let(nil, ::T.untyped)
11199
+ WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped)
11200
+ end
11201
+
11202
+ module SimpleCov::RawCoverage
11203
+ extend ::T::Sig
11204
+ end
11205
+
11206
+ module SimpleCov::ResultMerger
11207
+ extend ::T::Sig
11208
+ end
11209
+
11210
+ module SimpleCov
11211
+ extend ::T::Sig
11212
+ end
11213
+
9184
11214
  class SimpleDelegator
9185
11215
  extend ::T::Sig
9186
11216
  end
9187
11217
 
11218
+ module SingleForwardable
11219
+ def def_delegator(accessor, method, ali=T.unsafe(nil)); end
11220
+
11221
+ def def_delegators(accessor, *methods); end
11222
+
11223
+ def def_single_delegator(accessor, method, ali=T.unsafe(nil)); end
11224
+
11225
+ def def_single_delegators(accessor, *methods); end
11226
+
11227
+ def delegate(hash); end
11228
+
11229
+ def single_delegate(hash); end
11230
+ end
11231
+
11232
+ module SingleForwardable
11233
+ extend ::T::Sig
11234
+ end
11235
+
9188
11236
  module Singleton
9189
11237
  def _dump(depth=T.unsafe(nil)); end
9190
11238
 
@@ -9620,6 +11668,18 @@ class Sorbet
9620
11668
  extend ::T::Sig
9621
11669
  end
9622
11670
 
11671
+ module Sord::Logging
11672
+ extend ::T::Sig
11673
+ end
11674
+
11675
+ module Sord::Resolver
11676
+ extend ::T::Sig
11677
+ end
11678
+
11679
+ module Sord::TypeConverter
11680
+ extend ::T::Sig
11681
+ end
11682
+
9623
11683
  module Sord
9624
11684
  extend ::T::Sig
9625
11685
  end
@@ -9817,6 +11877,8 @@ class Struct
9817
11877
 
9818
11878
  def each_pair(); end
9819
11879
 
11880
+ def filter(*_); end
11881
+
9820
11882
  def length(); end
9821
11883
 
9822
11884
  def members(); end
@@ -10100,7 +12162,15 @@ class Time
10100
12162
  end
10101
12163
 
10102
12164
  class TracePoint
12165
+ def __enable(_, _1); end
12166
+
12167
+ def eval_script(); end
12168
+
10103
12169
  def event(); end
12170
+
12171
+ def instruction_sequence(); end
12172
+
12173
+ def parameters(); end
10104
12174
  end
10105
12175
 
10106
12176
  class TracePoint
@@ -10160,6 +12230,21 @@ class URI::FTP
10160
12230
  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
10161
12231
  end
10162
12232
 
12233
+ class URI::File
12234
+ def check_password(user); end
12235
+
12236
+ def check_user(user); end
12237
+
12238
+ def check_userinfo(user); end
12239
+
12240
+ def set_userinfo(v); end
12241
+ COMPONENT = ::T.let(nil, ::T.untyped)
12242
+ DEFAULT_PORT = ::T.let(nil, ::T.untyped)
12243
+ end
12244
+
12245
+ class URI::File
12246
+ end
12247
+
10163
12248
  class URI::Generic
10164
12249
  def +(oth); end
10165
12250
 
@@ -10489,6 +12574,8 @@ module Warning
10489
12574
  extend ::Warning
10490
12575
  end
10491
12576
 
12577
+ YAML = Psych
12578
+
10492
12579
  module YARD
10493
12580
  CONFIG_DIR = ::T.let(nil, ::T.untyped)
10494
12581
  ROOT = ::T.let(nil, ::T.untyped)
@@ -13431,7 +15518,7 @@ end
13431
15518
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP
13432
15519
  def add_html(tag, name); end
13433
15520
 
13434
- def add_special(pattern, name); end
15521
+ def add_regexp_handling(pattern, name); end
13435
15522
 
13436
15523
  def add_word_pair(start, stop, name); end
13437
15524
 
@@ -13472,7 +15559,7 @@ end
13472
15559
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttributeManager
13473
15560
  def add_html(tag, name); end
13474
15561
 
13475
- def add_special(pattern, name); end
15562
+ def add_regexp_handling(pattern, name); end
13476
15563
 
13477
15564
  def add_word_pair(start, stop, name); end
13478
15565
 
@@ -13488,7 +15575,7 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttributeManager
13488
15575
 
13489
15576
  def convert_html(str, attrs); end
13490
15577
 
13491
- def convert_specials(str, attrs); end
15578
+ def convert_regexp_handlings(str, attrs); end
13492
15579
 
13493
15580
  def copy_string(start_pos, end_pos); end
13494
15581
 
@@ -13504,7 +15591,7 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttributeManager
13504
15591
 
13505
15592
  def protectable(); end
13506
15593
 
13507
- def special(); end
15594
+ def regexp_handlings(); end
13508
15595
 
13509
15596
  def split_into_flow(); end
13510
15597
 
@@ -13526,7 +15613,7 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Attributes
13526
15613
 
13527
15614
  def each_name_of(bitmap); end
13528
15615
 
13529
- def special(); end
15616
+ def regexp_handling(); end
13530
15617
  end
13531
15618
 
13532
15619
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Attributes
@@ -13587,9 +15674,9 @@ end
13587
15674
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter
13588
15675
  def accept_document(document); end
13589
15676
 
13590
- def add_special_RDOCLINK(); end
15677
+ def add_regexp_handling_RDOCLINK(); end
13591
15678
 
13592
- def add_special_TIDYLINK(); end
15679
+ def add_regexp_handling_TIDYLINK(); end
13593
15680
 
13594
15681
  def add_tag(name, start, stop); end
13595
15682
 
@@ -13599,7 +15686,7 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter
13599
15686
 
13600
15687
  def convert_flow(flow); end
13601
15688
 
13602
- def convert_special(special); end
15689
+ def convert_regexp_handling(target); end
13603
15690
 
13604
15691
  def convert_string(string); end
13605
15692
 
@@ -13642,13 +15729,6 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter
13642
15729
  def self.gen_relative_url(path, target); end
13643
15730
  end
13644
15731
 
13645
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::FormatterTestCase
13646
- end
13647
-
13648
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::FormatterTestCase
13649
- def self.add_visitor_tests(); end
13650
- end
13651
-
13652
15732
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::HardBreak
13653
15733
  def ==(other); end
13654
15734
 
@@ -13873,14 +15953,7 @@ end
13873
15953
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Raw
13874
15954
  end
13875
15955
 
13876
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule
13877
- def accept(visitor); end
13878
- end
13879
-
13880
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule
13881
- end
13882
-
13883
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Special
15956
+ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::RegexpHandling
13884
15957
  def ==(o); end
13885
15958
 
13886
15959
  def initialize(type, text); end
@@ -13892,14 +15965,14 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Special
13892
15965
  def type(); end
13893
15966
  end
13894
15967
 
13895
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Special
15968
+ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::RegexpHandling
13896
15969
  end
13897
15970
 
13898
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::TextFormatterTestCase
15971
+ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule
15972
+ def accept(visitor); end
13899
15973
  end
13900
15974
 
13901
- class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::TextFormatterTestCase
13902
- def self.add_text_tests(); end
15975
+ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule
13903
15976
  end
13904
15977
 
13905
15978
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToAnsi
@@ -13954,13 +16027,13 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtml
13954
16027
 
13955
16028
  def handle_RDOCLINK(url); end
13956
16029
 
13957
- def handle_special_HARD_BREAK(special); end
16030
+ def handle_regexp_HARD_BREAK(target); end
13958
16031
 
13959
- def handle_special_HYPERLINK(special); end
16032
+ def handle_regexp_HYPERLINK(target); end
13960
16033
 
13961
- def handle_special_RDOCLINK(special); end
16034
+ def handle_regexp_RDOCLINK(target); end
13962
16035
 
13963
- def handle_special_TIDYLINK(special); end
16036
+ def handle_regexp_TIDYLINK(target); end
13964
16037
 
13965
16038
  def html_list_name(list_type, open_tag); end
13966
16039
 
@@ -13992,13 +16065,13 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlCrossref
13992
16065
 
13993
16066
  def context=(context); end
13994
16067
 
13995
- def cross_reference(name, text=T.unsafe(nil)); end
16068
+ def cross_reference(name, text=T.unsafe(nil), code=T.unsafe(nil)); end
13996
16069
 
13997
- def handle_special_CROSSREF(special); end
16070
+ def handle_regexp_CROSSREF(target); end
13998
16071
 
13999
16072
  def initialize(options, from_path, context, markup=T.unsafe(nil)); end
14000
16073
 
14001
- def link(name, text); end
16074
+ def link(name, text, code=T.unsafe(nil)); end
14002
16075
 
14003
16076
  def show_hash(); end
14004
16077
 
@@ -14023,7 +16096,7 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlSnippet
14023
16096
 
14024
16097
  def characters(); end
14025
16098
 
14026
- def handle_special_CROSSREF(special); end
16099
+ def handle_regexp_CROSSREF(target); end
14027
16100
 
14028
16101
  def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end
14029
16102
 
@@ -14097,11 +16170,11 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToLabel
14097
16170
 
14098
16171
  def end_accepting(*node); end
14099
16172
 
14100
- def handle_special_CROSSREF(special); end
16173
+ def handle_regexp_CROSSREF(target); end
14101
16174
 
14102
- def handle_special_HARD_BREAK(*node); end
16175
+ def handle_regexp_HARD_BREAK(*node); end
14103
16176
 
14104
- def handle_special_TIDYLINK(special); end
16177
+ def handle_regexp_TIDYLINK(target); end
14105
16178
 
14106
16179
  def initialize(markup=T.unsafe(nil)); end
14107
16180
 
@@ -14118,9 +16191,9 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToMarkdown
14118
16191
 
14119
16192
  def handle_rdoc_link(url); end
14120
16193
 
14121
- def handle_special_RDOCLINK(special); end
16194
+ def handle_regexp_RDOCLINK(target); end
14122
16195
 
14123
- def handle_special_TIDYLINK(special); end
16196
+ def handle_regexp_TIDYLINK(target); end
14124
16197
  end
14125
16198
 
14126
16199
  class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToMarkdown
@@ -14155,9 +16228,9 @@ class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToRdoc
14155
16228
 
14156
16229
  def end_accepting(); end
14157
16230
 
14158
- def handle_special_HARD_BREAK(special); end
16231
+ def handle_regexp_HARD_BREAK(target); end
14159
16232
 
14160
- def handle_special_SUPPRESSED_CROSSREF(special); end
16233
+ def handle_regexp_SUPPRESSED_CROSSREF(target); end
14161
16234
 
14162
16235
  def indent(); end
14163
16236