diff --git a/Gemfile.lock b/Gemfile.lock index c73e3535a..6faa185fd 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -136,7 +136,7 @@ GEM bigdecimal rexml crass (1.0.7) - dalli (5.1.1) + dalli (5.2.2) logger date (3.5.1) debug (1.11.1) @@ -178,7 +178,7 @@ GEM google-protobuf (4.36.2-x86_64-linux-musl) bigdecimal rake (~> 13.3) - graphql (2.6.11) + graphql (2.6.12) base64 fiber-storage logger @@ -195,7 +195,7 @@ GEM prism (>= 1.3.0) rdoc (>= 4.0.0) reline (>= 0.4.2) - json (3.0.2) + json (3.1.0) kramdown (2.5.2) rexml (>= 3.4.4) kredis (1.8.0) @@ -254,7 +254,7 @@ GEM nokogiri (1.19.4-x86_64-linux-musl) racc (~> 1.4) ostruct (0.6.2) - parallel (2.2.0) + parallel (2.3.0) parser (3.3.12.0) ast (~> 2.4.1) racc @@ -304,7 +304,7 @@ GEM zeitwerk (~> 2.6) rainbow (3.1.1) rake (13.4.2) - rbi (0.4.3) + rbi (0.5.0) prism (~> 1.0) rbs (>= 4.0.1) rbs (4.2.0) @@ -325,14 +325,14 @@ GEM io-console (~> 0.5) require-hooks (0.5.1) rexml (3.4.4) - rubocop (1.91.0) + rubocop (1.92.0) json (>= 2.3) language_server-protocol (~> 3.17.0.2) lint_roller (~> 1.1.0) parallel (>= 1.10) parser (>= 3.3.0.2) rainbow (>= 2.2.2, < 4.0) - regexp_parser (>= 2.9.3, < 3.0) + regexp_parser (>= 2.11.3, < 3.0) rubocop-ast (>= 1.49.0, < 2.0) ruby-progressbar (~> 1.7) unicode-display_width (>= 2.4.0, < 4.0) @@ -346,9 +346,10 @@ GEM rubocop-shopify (3.1.0) lint_roller rubocop (~> 1.89) - rubocop-sorbet (0.16.0) + rubocop-sorbet (0.17.1) lint_roller - rbi (~> 0.4) + rbi (~> 0.4, >= 0.4.3) + rbs (>= 4.1.1) rubocop (>= 1.75.2) spoom (~> 1.8) ruby-lsp (0.26.11) @@ -372,16 +373,16 @@ GEM rack (>= 3.2.0) redis-client (>= 0.29.0) smart_properties (1.17.0) - sorbet (0.6.13508) - sorbet-static (= 0.6.13508) - sorbet-runtime (0.6.13508) - sorbet-static (0.6.13508-aarch64-linux) - sorbet-static (0.6.13508-universal-darwin) - sorbet-static (0.6.13508-x86_64-linux) - sorbet-static-and-runtime (0.6.13508) - sorbet (= 0.6.13508) - sorbet-runtime (= 0.6.13508) - spoom (1.8.9) + sorbet (0.6.13571) + sorbet-static (= 0.6.13571) + sorbet-runtime (0.6.13571) + sorbet-static (0.6.13571-aarch64-linux) + sorbet-static (0.6.13571-universal-darwin) + sorbet-static (0.6.13571-x86_64-linux) + sorbet-static-and-runtime (0.6.13571) + sorbet (= 0.6.13571) + sorbet-runtime (= 0.6.13571) + spoom (1.8.12) erubi (>= 1.10.0) prism (>= 0.28.0) rbi (>= 0.4.2) @@ -410,7 +411,7 @@ GEM unicode-emoji (4.3.0) uri (1.1.1) useragent (0.16.11) - webmock (3.26.4) + webmock (3.34.0) addressable (>= 2.8.0) crack (>= 0.3.2) hashdiff (>= 0.4.0, < 2.0.0) @@ -511,7 +512,7 @@ CHECKSUMS connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a crack (1.0.1) sha256=ff4a10390cd31d66440b7524eb1841874db86201d5b70032028553130b6d4c7e crass (1.0.7) sha256=94868719948664c89ddcaf0a37c65048413dfcb1c869470a5f7a7ceb5390b295 - dalli (5.1.1) sha256=d3436b2c40c296c4818e571fadaf0070f01890198261cb6eb8068d8e81eea32f + dalli (5.2.2) sha256=23ad7dd2891525b720be39a550eba144bebebfe807d3d51b4582be2997d63f73 date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0 debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6 deep_merge (1.2.2) sha256=83ced3a3d7f95f67de958d2ce41b1874e83c8d94fe2ddbff50c8b4b82323563a @@ -530,13 +531,13 @@ CHECKSUMS google-protobuf (4.36.2-x86_64-darwin) sha256=8d1bd2a344f7f589703b202ad2ee4cca8ef731b4ced45782ef92d385967384ba google-protobuf (4.36.2-x86_64-linux-gnu) sha256=d25a820873e423f1d209ae8c672a4a28b019e2429debd0901d26670a0b4e14db google-protobuf (4.36.2-x86_64-linux-musl) sha256=0fa17686c896da96a60a705e56ddc7d4ff56413f52787c655bd4c9fb33ffe14f - graphql (2.6.11) sha256=9a9cde910e805c4c08fdf8d22bf129e935affc9ca8b4f9b2ec26b4b63666b15d + graphql (2.6.12) sha256=262ddb700d27c53ffbd4878376b20337d4d084d79da567c675536b7a50ddc102 hashdiff (1.2.1) sha256=9c079dbc513dfc8833ab59c0c2d8f230fa28499cc5efb4b8dd276cf931457cd1 i18n (1.15.2) sha256=00f9eb62412fe593b2a65a97daa75300d37abb8f7202ec748e94b6d46a9dd1b5 identity_cache (1.6.5) sha256=cbac45390561ce59f399ae671019f350bb1e7090ae7ded4bbe5249de6691da2b io-console (0.9.4) sha256=a403304f32928ee85e56d457b4612ca43f2703b561a3258844992bd24085fbb1 irb (1.18.0) sha256=de9454a0703a54704b9811a5ef31a60c86949fbf4013fcf244fabc7c775248e3 - json (3.0.2) sha256=8e6d7e7b11384c21230430cef90b71f14849a34a1f4452796670f7c981bd19df + json (3.1.0) sha256=3ce7ccf8fde58960177a3a756c31f292a4c1e1dedee884547096a5b0604e3bd8 json_api_client (1.23.0) kramdown (2.5.2) sha256=1ba542204c66b6f9111ff00dcc26075b95b220b07f2905d8261740c82f7f02fa kredis (1.8.0) sha256=34b72a0bc242d7aaea98e82b6a5a8c293a27e1b26f2c729a8d4e1e1409886150 @@ -566,7 +567,7 @@ CHECKSUMS nokogiri (1.19.4-x86_64-linux-gnu) sha256=379fae440b28915e3f19d752ce2dcf8465ed2b2fbefd2a7ca0dd497bc981a06a nokogiri (1.19.4-x86_64-linux-musl) sha256=17dfb7c1fa194ae02fbf7c51a7afc8d278045ab3fdacfd86f91d02d7b274470b ostruct (0.6.2) sha256=6d7302a299e400a2c248d6ce0dad18fc3a5714e8096facc25ffd0c54ee57cfc0 - parallel (2.2.0) sha256=e1059c5fd7b649558a0aec38a769f06a42942bdb40503d005a59c352fe011cd8 + parallel (2.3.0) sha256=f75a3e904101ce6a1ccb6b8dc800cbafd42166d83330192438dcf29395167a6f parser (3.3.12.0) sha256=21a6d7f755d5a24dfbdc6e6b772e4e879a52e7631a88bc5a3a134606052c9828 pp (0.6.4) sha256=dfcb0fce700c41456265922884f9fe195d7fbb0674a3578e6c0f69588e82b570 prettyprint (0.2.0) sha256=2bc9e15581a94742064a3cc8b0fb9d45aae3d03a1baa6ef80922627a0766f193 @@ -583,7 +584,7 @@ CHECKSUMS railties (8.1.4) sha256=b5e7a8e8984e33114d68af62227971960aae1e6c02bd7c9d826ffad97fff583c rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701 - rbi (0.4.3) sha256=cc090ae62c3246412b992954f54077d6046c9b04f1537a4d24bfae8714503eac + rbi (0.5.0) sha256=8311af9761f2e89b1448c4b2cfba18b3b3a90b0d03056879fd6f5483b9c3adab rbs (4.2.0) sha256=51f7b886dcc05bc09e10b901daa6a81829f6adc03101d6ca9ea4aac6103e0674 rdoc (8.1.0) sha256=befc37880a5cfd36dcb176c748b5fd5ee39dd3536a75e81824e4972ce230f60a redis (5.4.0) sha256=798900d869418a9fc3977f916578375b45c38247a556b61d58cba6bb02f7d06b @@ -592,11 +593,11 @@ CHECKSUMS reline (0.7.0) sha256=5b012d8e55dbf9d450f12bde2cf7d15ff546ae80b3f8f3b30e570d431815583d require-hooks (0.5.1) sha256=49a6b14518b91c5b8006d0644ef257af0ca033df23625bd4e314a8c5282191d9 rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142 - rubocop (1.91.0) sha256=9c82b7bf391c5d7e3798c5b9996e22a1fe3bd7468e351dfdeb96140c058296d0 + rubocop (1.92.0) sha256=2af68041fb2e70bd9321d0479b49fad07f8008a3d0758c83347b4917128c56e0 rubocop-ast (1.50.0) sha256=b9ca88300da0803ee222ad20cdb30494c0a784eed06fdc35d254b06d662788db rubocop-rspec (3.10.2) sha256=0b3e2ecc592cd10ecbf0095bb58d1e357905276e069643523cc19eb7495f65e2 rubocop-shopify (3.1.0) sha256=0345309997d5d9b544c13b967ca64e51437bd573bdc79a30f1e0e72956d85c29 - rubocop-sorbet (0.16.0) sha256=7e6970a4de3fcd1c9453aff007f55b09ae617bbb68182591b2668328f6997988 + rubocop-sorbet (0.17.1) sha256=b5043f8a2cb85b0afd9c92934a41ee19ce907be13bdd6a803ef8f154d8a3f1f4 ruby-lsp (0.26.11) sha256=4cc8f1587237ff8c9031680b5491df901a82559eeaa1ae96863ffe700b32583d ruby-lsp-rails (0.4.8) sha256=f09d1f926d4063deeb2f3049311925c20dfe6c912371e3bcd04a265a865c44ae ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33 @@ -608,13 +609,13 @@ CHECKSUMS shopify-money (4.1.1) sha256=523078e44bfde1920f8b3487ddf9144e0fb6af8cdf67e212bed02025c5c5f423 sidekiq (8.1.7) sha256=91ad48c7e6c32e1846bf1d5b74c27948758049b93fed0cb539f8d586c7de3415 smart_properties (1.17.0) sha256=f9323f8122e932341756ddec8e0ac9ec6e238408a7661508be99439ca6d6384b - sorbet (0.6.13508) sha256=de67c75424731d39ac529639ff6849c3fe33d91c94608765d912d35efa5941a2 - sorbet-runtime (0.6.13508) sha256=011ee266adead459077ebc0058d36aeb75d6c90968db8524916050ce3c62e526 - sorbet-static (0.6.13508-aarch64-linux) sha256=1c54603399d40d78d6e73c853c5e0b6dcfc34105a92f6630f4a5329d1e6ed3c0 - sorbet-static (0.6.13508-universal-darwin) sha256=65280392d193ca85828b13d07bb8eb90f41ad57f8d9bc79c5edcd078aa7dc308 - sorbet-static (0.6.13508-x86_64-linux) sha256=57fd620b1a747baad432ef5c2bc2cd6218664e00626fc4e7fb5ed5f633e3a286 - sorbet-static-and-runtime (0.6.13508) sha256=874d9fe5d98eebddd322629ee3d27021a6da32594edfa170295c0b4bcd285d66 - spoom (1.8.9) sha256=4f81c6b6c94665de0f548323197667e92fc6bcd888299030019354db79f61a78 + sorbet (0.6.13571) sha256=b726c0921ad0eb9c37ef3562cfdae2aa71fd526fffdff498b629948d4dda6c65 + sorbet-runtime (0.6.13571) sha256=deddfa1e22d7caf4e2ba697eb2907c7a04a1192e7483270e5556a2ef13ea7d21 + sorbet-static (0.6.13571-aarch64-linux) sha256=6020d95fbdb3e998a171b2f8d439f9a2748ed0a0a7b5bf8e24be08c56e8d5d08 + sorbet-static (0.6.13571-universal-darwin) sha256=a985c5f832f0729ff6eddda991f4584b746e6abe6554641b366671c3bc36aeb2 + sorbet-static (0.6.13571-x86_64-linux) sha256=cdecdcdb836a33ff08134da62cc5520697157c8a9d985624a467a8800cb56cb6 + sorbet-static-and-runtime (0.6.13571) sha256=fab7ad5c7b4196544aa7a2cb80e5dcc65f61099dbff901245faaaefecdcca788 + spoom (1.8.12) sha256=089606b042dbe84185361e3e31c7902099877d5f47bb62e972efc43029f62cd5 sprockets (4.4.1) sha256=fbd665edad0916de5c7abefef0fc616866a60c5e48ce2846f39ac3fc5df9e184 sqlite3 (2.9.6-aarch64-linux-gnu) sha256=d8b1f7d23efd7abac285775a9566562fc7debfef79d594e3a20354406fb7907c sqlite3 (2.9.6-aarch64-linux-musl) sha256=3579e1c98cdc7ff5c3722847bb63ed4e1efb7ff675cb5e1e48ef2d4da5fb3bc9 @@ -632,7 +633,7 @@ CHECKSUMS unicode-emoji (4.3.0) sha256=11c02fa73290378c066bb0562cd4c87d8e1b706fbbe0059ca12746a4244de8ce uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6 useragent (0.16.11) sha256=700e6413ad4bb954bb63547fa098dddf7b0ebe75b40cc6f93b8d54255b173844 - webmock (3.26.4) sha256=8d8da206d217ebe6968cfb09c77f4533c23074e1432bad865f3994eacbaad50d + webmock (3.34.0) sha256=72eed29dc8c00148d592acaedaaa6b869e2e397de57dfc8602b84aa834f46b33 websocket-driver (0.8.2) sha256=97c556b019bf3410b4961002ac501621e9322d3f8a7bc02161a09301cc4c4146 websocket-extensions (0.1.5) sha256=1c6ba63092cda343eb53fc657110c71c754c56484aad42578495227d717a8241 xpath (3.2.0) sha256=6dfda79d91bb3b949b947ecc5919f042ef2f399b904013eb3ef6d20dd3a4082e diff --git a/sorbet/rbi/gems/dalli@5.1.1.rbi b/sorbet/rbi/gems/dalli@5.2.2.rbi similarity index 76% rename from sorbet/rbi/gems/dalli@5.1.1.rbi rename to sorbet/rbi/gems/dalli@5.2.2.rbi index 4ae7794d8..895568a56 100644 --- a/sorbet/rbi/gems/dalli@5.1.1.rbi +++ b/sorbet/rbi/gems/dalli@5.2.2.rbi @@ -24,6 +24,69 @@ module Dalli end end +# An immutable, typed view over the Hash returned by Client#get_with_metadata +# and Client#get_multi_with_metadata. +# +# This is an interim adapter (see #1130 / #1151): #get_with_metadata and +# #get_multi_with_metadata keep returning a Hash for now, since changing +# their return type is a breaking change reserved for a future major +# version. #get_with_metadata_result and #get_multi_with_metadata_result +# wrap that Hash in this type instead, so the structured shape can be +# validated by callers ahead of that change. +# +# pkg:gem/dalli#lib/dalli/cache_result.rb:15 +class Dalli::CacheResult + # @param hash [Hash] a Hash as returned by Client#get_with_metadata, or a + # single value from the Hash returned by Client#get_multi_with_metadata + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:20 + def initialize(hash); end + + # pkg:gem/dalli#lib/dalli/cache_result.rb:16 + def cas; end + + # The inverse of #miss?. + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:43 + def hit?; end + + # pkg:gem/dalli#lib/dalli/cache_result.rb:16 + def hit_before; end + + # pkg:gem/dalli#lib/dalli/cache_result.rb:16 + def last_access; end + + # True if another client already won the recache race for this key. + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:61 + def lost_recache?; end + + # True when the key did not exist. Prefer this over a nil #value, which + # cannot distinguish a miss from a stored nil under cache_nils. + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:38 + def miss?; end + + # True when the item is a tombstone (marked stale via the meta protocol's + # invalidate flag) rather than removed. Not a miss: #value is still the + # last-known value unless the tombstone also dropped it. + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:50 + def stale?; end + + # pkg:gem/dalli#lib/dalli/cache_result.rb:16 + def ttl_remaining; end + + # pkg:gem/dalli#lib/dalli/cache_result.rb:16 + def value; end + + # True if this call won the right to regenerate the value under + # thundering-herd protection (see Client#fetch_with_lock). + # + # pkg:gem/dalli#lib/dalli/cache_result.rb:56 + def won_recache?; end +end + # Dalli::Client is the main class which developers will use to interact with # Memcached. # @@ -70,28 +133,36 @@ class Dalli::Client # +:include+ logs the full operation and key(s), +:obfuscate+ replaces keys with "?", # +nil+ (default) omits the attribute entirely. # - :otel_peer_service - when set, adds a +peer.service+ span attribute with this value for logical service naming. - # - # pkg:gem/dalli#lib/dalli/client.rb:54 + # - :defer_drain - defaults to false. When true, a quiet/multi block no longer waits at its end for the replies + # to its requests. The requests are still sent right away; their replies are read (with one noop + # per server) just before the next non-quiet request to that server, or by + # #drain_deferred_responses. The tradeoff: an error reply to a quiet request surfaces, and is + # discarded, at that later point rather than when the block ends. Replies memcached sends for + # quiet requests (NF, NS, errors) wait on the connection until then, so a client that only makes + # quiet requests should call #drain_deferred_responses periodically. See "Deferred Draining" in + # the README. + # + # pkg:gem/dalli#lib/dalli/client.rb:62 def initialize(servers = T.unsafe(nil), options = T.unsafe(nil)); end # Conditionally add a key/value pair, if the key does not already exist # on the server. Returns truthy if the operation succeeded. # - # pkg:gem/dalli#lib/dalli/client.rb:418 + # pkg:gem/dalli#lib/dalli/client.rb:485 def add(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Make sure memcache servers are alive, or raise an Dalli::RingError # - # pkg:gem/dalli#lib/dalli/client.rb:627 + # pkg:gem/dalli#lib/dalli/client.rb:694 def alive!; end # Append value to the value already stored on the server for 'key'. # Appending only works for values stored with :raw => true. # - # pkg:gem/dalli#lib/dalli/client.rb:521 + # pkg:gem/dalli#lib/dalli/client.rb:588 def append(key, value, req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:647 + # pkg:gem/dalli#lib/dalli/client.rb:714 def cache_nils; end # compare and swap values using optimistic locking. @@ -105,7 +176,7 @@ class Dalli::Client # - false if the value was changed by someone else. # - true if the value was successfully updated. # - # pkg:gem/dalli#lib/dalli/client.rb:329 + # pkg:gem/dalli#lib/dalli/client.rb:381 def cas(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil), &); end # like #cas, but will yield to the block whether or not the value @@ -115,13 +186,13 @@ class Dalli::Client # - false if the value was changed by someone else. # - true if the value was successfully updated. # - # pkg:gem/dalli#lib/dalli/client.rb:340 + # pkg:gem/dalli#lib/dalli/client.rb:392 def cas!(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil), &); end # Close our connection to each server. # If you perform another operation after this, the connections will be re-established. # - # pkg:gem/dalli#lib/dalli/client.rb:634 + # pkg:gem/dalli#lib/dalli/client.rb:701 def close; end # Decr subtracts the given amount from the counter on the memcached server. @@ -142,7 +213,7 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:575 + # pkg:gem/dalli#lib/dalli/client.rb:642 def decr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil), req_options = T.unsafe(nil)); end # Delete a key. @@ -171,7 +242,7 @@ class Dalli::Client # @param key [String] the key to delete # @param req_options [Hash, nil] meta-delete options # - # pkg:gem/dalli#lib/dalli/client.rb:476 + # pkg:gem/dalli#lib/dalli/client.rb:543 def delete(key, req_options = T.unsafe(nil)); end # Delete a key/value pair, verifying existing CAS. @@ -180,7 +251,7 @@ class Dalli::Client # # `req_options` accepts the same meta-delete options as #delete. # - # pkg:gem/dalli#lib/dalli/client.rb:444 + # pkg:gem/dalli#lib/dalli/client.rb:511 def delete_cas(key, cas = T.unsafe(nil), req_options = T.unsafe(nil)); end # Delete multiple keys efficiently using pipelining. @@ -206,9 +277,21 @@ class Dalli::Client # client.delete_multi(['key1', 'key2', 'key3']) # client.delete_multi(%w[key1 key2], invalidate: true, tombstone_ttl: 30) # - # pkg:gem/dalli#lib/dalli/client.rb:503 + # pkg:gem/dalli#lib/dalli/client.rb:570 def delete_multi(keys, req_options = T.unsafe(nil)); end + # Reads and discards the replies still pending from quiet requests, on the + # servers that have any. Only needed with the defer_drain option. + # + # Normally the next non-quiet request to a server drains its pending + # replies first. A client that only makes quiet requests (for example, a + # worker that only issues quiet deletes) never does, so its replies keep + # accumulating on the socket; call this periodically, such as after each + # batch or job. It sends nothing to servers with no quiet requests pending. + # + # pkg:gem/dalli#lib/dalli/client.rb:433 + def drain_deferred_responses; end + # Fetch the value associated with the key. # If a value is found, then it is returned. # @@ -218,7 +301,7 @@ class Dalli::Client # and a block is given, the block will be invoked and its return value # written to the cache and returned. # - # pkg:gem/dalli#lib/dalli/client.rb:259 + # pkg:gem/dalli#lib/dalli/client.rb:308 def fetch(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Fetch the value with thundering herd protection using the meta protocol's @@ -250,35 +333,35 @@ class Dalli::Client # expensive_operation # end # - # pkg:gem/dalli#lib/dalli/client.rb:299 + # pkg:gem/dalli#lib/dalli/client.rb:348 def fetch_with_lock(key, ttl: T.unsafe(nil), lock_ttl: T.unsafe(nil), recache_threshold: T.unsafe(nil), req_options: T.unsafe(nil), &block); end # Flush the memcached server, at 'delay' seconds in the future. # Delay defaults to zero seconds, which means an immediate flush. # - # pkg:gem/dalli#lib/dalli/client.rb:587 + # pkg:gem/dalli#lib/dalli/client.rb:654 def flush(delay = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:590 + # pkg:gem/dalli#lib/dalli/client.rb:657 def flush_all(delay = T.unsafe(nil)); end # Gat (get and touch) fetch an item and simultaneously update its expiration time. # # If a value is not found, then +nil+ is returned. # - # pkg:gem/dalli#lib/dalli/client.rb:78 + # pkg:gem/dalli#lib/dalli/client.rb:86 def gat(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Get the value associated with the key. # If a value is not found, then +nil+ is returned. # - # pkg:gem/dalli#lib/dalli/client.rb:69 + # pkg:gem/dalli#lib/dalli/client.rb:77 def get(key, req_options = T.unsafe(nil)); end # Get the value and CAS ID associated with the key. If a block is provided, # value and CAS will be passed to the block. # - # pkg:gem/dalli#lib/dalli/client.rb:95 + # pkg:gem/dalli#lib/dalli/client.rb:103 def get_cas(key, req_options = T.unsafe(nil)); end # Fetch multiple keys efficiently. @@ -293,7 +376,7 @@ class Dalli::Client # # @raise [Dalli::NetworkError] if a server is unreachable after retrying # - # pkg:gem/dalli#lib/dalli/client.rb:165 + # pkg:gem/dalli#lib/dalli/client.rb:193 def get_multi(*keys, req_options: T.unsafe(nil)); end # Fetch multiple keys efficiently, including available metadata such as CAS. @@ -304,7 +387,7 @@ class Dalli::Client # # `req_options` accepts :p_token/:l_token, applied to every key in the batch. # - # pkg:gem/dalli#lib/dalli/client.rb:239 + # pkg:gem/dalli#lib/dalli/client.rb:288 def get_multi_cas(*keys, req_options: T.unsafe(nil)); end # Fetch multiple keys efficiently, returning a stale-aware metadata Hash per @@ -332,9 +415,29 @@ class Dalli::Client # @param req_options [Hash, nil] routing-token options # @return [Hash] key => { value:, cas:, stale:, miss: } # - # pkg:gem/dalli#lib/dalli/client.rb:204 + # pkg:gem/dalli#lib/dalli/client.rb:232 def get_multi_with_metadata(*keys, req_options: T.unsafe(nil), &block); end + # Like #get_multi_with_metadata, but wraps each entry's Hash in a + # Dalli::CacheResult instead. Missing keys are still omitted; no block + # form. + # + # Interim adapter (see #1130 / #1151): #get_multi_with_metadata itself + # keeps returning a Hash of Hashes, since changing that return type is a + # breaking change reserved for a future major version. This lets callers + # opt in to the structured shape today. + # + # Result key order follows #get_multi_with_metadata's own: request order + # only when every key lands on the same server, per-server response order + # otherwise. + # + # @param keys [Array] the keys to fetch + # @param req_options [Hash, nil] see #get_multi_with_metadata + # @return [Hash] key => Dalli::CacheResult + # + # pkg:gem/dalli#lib/dalli/client.rb:276 + def get_multi_with_metadata_result(*keys, req_options: T.unsafe(nil)); end + # Get value with extended metadata. # # @param key [String] the cache key @@ -368,9 +471,24 @@ class Dalli::Client # ) # # => { value: "data", cas: 123, hit_before: true, last_access: 42 } # - # pkg:gem/dalli#lib/dalli/client.rb:137 + # pkg:gem/dalli#lib/dalli/client.rb:145 def get_with_metadata(key, options = T.unsafe(nil)); end + # Like #get_with_metadata, but wraps the result in a Dalli::CacheResult + # instead of returning a Hash. + # + # Interim adapter (see #1130 / #1151): #get_with_metadata itself keeps + # returning a Hash, since changing that return type is a breaking change + # reserved for a future major version. This lets callers opt in to the + # structured shape today. + # + # @param key [String] the cache key + # @param options [Hash] see #get_with_metadata + # @return [Dalli::CacheResult] + # + # pkg:gem/dalli#lib/dalli/client.rb:176 + def get_with_metadata_result(key, options = T.unsafe(nil)); end + # Incr adds the given amount to the counter on the memcached server. # Amt must be a positive integer value. # Default, if given, must be an Integer (or a String of decimal digits); @@ -386,19 +504,19 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:549 + # pkg:gem/dalli#lib/dalli/client.rb:616 def incr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil), req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:369 + # pkg:gem/dalli#lib/dalli/client.rb:422 def multi; end - # pkg:gem/dalli#lib/dalli/client.rb:643 + # pkg:gem/dalli#lib/dalli/client.rb:710 def not_found?(val); end # Prepend value to the value already stored on the server for 'key'. # Prepending only works for values stored with :raw => true. # - # pkg:gem/dalli#lib/dalli/client.rb:529 + # pkg:gem/dalli#lib/dalli/client.rb:596 def prepend(key, value, req_options = T.unsafe(nil)); end # Turn on quiet aka noreply support for a number of @@ -414,41 +532,42 @@ class Dalli::Client # arithmetic (incr, decr), flush and delete operations. Use of # unsupported operations inside a block will raise an error. # - # Any error replies will be discarded at the end of the block, and + # Any error replies will be discarded at the end of the block (or, with + # the defer_drain option, before the next non-quiet request), and # Dalli client methods invoked inside the block will not # have return values # - # pkg:gem/dalli#lib/dalli/client.rb:361 + # pkg:gem/dalli#lib/dalli/client.rb:414 def quiet; end # Conditionally add a key/value pair, only if the key already exists # on the server. Returns truthy if the operation succeeded. # - # pkg:gem/dalli#lib/dalli/client.rb:426 + # pkg:gem/dalli#lib/dalli/client.rb:493 def replace(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Conditionally add a key/value pair, verifying existing CAS, only if the # key already exists on the server. Returns the new CAS value if the # operation succeeded, or falsy otherwise. # - # pkg:gem/dalli#lib/dalli/client.rb:434 + # pkg:gem/dalli#lib/dalli/client.rb:501 def replace_cas(key, value, cas, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:638 + # pkg:gem/dalli#lib/dalli/client.rb:705 def reset; end # Reset stats for each server. # - # pkg:gem/dalli#lib/dalli/client.rb:609 + # pkg:gem/dalli#lib/dalli/client.rb:676 def reset_stats; end - # pkg:gem/dalli#lib/dalli/client.rb:371 + # pkg:gem/dalli#lib/dalli/client.rb:438 def set(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Set the key-value pair, verifying existing CAS. # Returns the resulting CAS value if succeeded, and falsy otherwise. # - # pkg:gem/dalli#lib/dalli/client.rb:410 + # pkg:gem/dalli#lib/dalli/client.rb:477 def set_cas(key, value, cas, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Set multiple keys and values efficiently using pipelining. @@ -469,62 +588,62 @@ class Dalli::Client # Example: # client.set_multi({ 'key1' => 'value1', 'key2' => 'value2' }, 300) # - # pkg:gem/dalli#lib/dalli/client.rb:393 + # pkg:gem/dalli#lib/dalli/client.rb:460 def set_multi(hash, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Collect the stats for each server. # You can optionally pass a type including :items, :slabs or :settings to get specific stats # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } } # - # pkg:gem/dalli#lib/dalli/client.rb:598 + # pkg:gem/dalli#lib/dalli/client.rb:665 def stats(type = T.unsafe(nil)); end # Touch updates expiration time for a given key. # # Returns true if key exists, otherwise nil. # - # pkg:gem/dalli#lib/dalli/client.rb:87 + # pkg:gem/dalli#lib/dalli/client.rb:95 def touch(key, ttl = T.unsafe(nil)); end # Version of the memcache servers. # - # pkg:gem/dalli#lib/dalli/client.rb:617 + # pkg:gem/dalli#lib/dalli/client.rb:684 def version; end # Stub method so a bare Dalli client can pretend to be a connection pool. # - # pkg:gem/dalli#lib/dalli/client.rb:652 + # pkg:gem/dalli#lib/dalli/client.rb:719 def with; end private - # pkg:gem/dalli#lib/dalli/client.rb:793 + # pkg:gem/dalli#lib/dalli/client.rb:861 def add_query_text(attrs, operation, key_or_keys); end - # pkg:gem/dalli#lib/dalli/client.rb:843 + # pkg:gem/dalli#lib/dalli/client.rb:913 def cas_core(key, always_set, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:803 + # pkg:gem/dalli#lib/dalli/client.rb:871 def check_positive!(amt); end - # pkg:gem/dalli#lib/dalli/client.rb:852 + # pkg:gem/dalli#lib/dalli/client.rb:922 def fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options); end # Only built when tracing is on, since the Hash is thrown away otherwise # - # pkg:gem/dalli#lib/dalli/client.rb:776 + # pkg:gem/dalli#lib/dalli/client.rb:844 def get_multi_attributes(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:701 + # pkg:gem/dalli#lib/dalli/client.rb:768 def get_multi_hash(keys, req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:689 + # pkg:gem/dalli#lib/dalli/client.rb:756 def get_multi_yielding(keys, req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:787 + # pkg:gem/dalli#lib/dalli/client.rb:855 def multi_trace_attrs(operation, key_count, keys); end - # pkg:gem/dalli#lib/dalli/client.rb:917 + # pkg:gem/dalli#lib/dalli/client.rb:989 def normalize_options(opts); end # Chokepoint method for memcached methods with a key argument. @@ -536,28 +655,28 @@ class Dalli::Client # a particular memcached instance becomes unreachable, or the # operation times out. # - # pkg:gem/dalli#lib/dalli/client.rb:894 + # pkg:gem/dalli#lib/dalli/client.rb:964 def perform(op, key, *, **, &); end - # pkg:gem/dalli#lib/dalli/client.rb:947 + # pkg:gem/dalli#lib/dalli/client.rb:1019 def pipelined_deleter; end - # pkg:gem/dalli#lib/dalli/client.rb:939 + # pkg:gem/dalli#lib/dalli/client.rb:1011 def pipelined_getter; end - # pkg:gem/dalli#lib/dalli/client.rb:943 + # pkg:gem/dalli#lib/dalli/client.rb:1015 def pipelined_setter; end - # pkg:gem/dalli#lib/dalli/client.rb:682 + # pkg:gem/dalli#lib/dalli/client.rb:749 def record_hit_miss_metrics(span, key_count, hit_count); end - # pkg:gem/dalli#lib/dalli/client.rb:879 + # pkg:gem/dalli#lib/dalli/client.rb:949 def ring; end - # pkg:gem/dalli#lib/dalli/client.rb:715 + # pkg:gem/dalli#lib/dalli/client.rb:782 def single_server; end - # pkg:gem/dalli#lib/dalli/client.rb:764 + # pkg:gem/dalli#lib/dalli/client.rb:832 def single_server_delete_multi(keys, req_options = T.unsafe(nil)); end # The three single_server_* fast-path methods below share one contract, @@ -570,22 +689,22 @@ class Dalli::Client # to route to at all is still silent, matching Ring#keys_grouped_by_server # dropping a key it can't route on both the single- and multi-server paths. # - # pkg:gem/dalli#lib/dalli/client.rb:729 + # pkg:gem/dalli#lib/dalli/client.rb:796 def single_server_get_multi(keys, req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:742 + # pkg:gem/dalli#lib/dalli/client.rb:810 def single_server_get_multi_with_metadata(keys, req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:753 + # pkg:gem/dalli#lib/dalli/client.rb:821 def single_server_set_multi(hash, ttl, req_options); end - # pkg:gem/dalli#lib/dalli/client.rb:780 + # pkg:gem/dalli#lib/dalli/client.rb:848 def trace_attrs(operation, key, server); end # Uses the argument TTL or the client-wide default. Ensures # that the value is an integer # - # pkg:gem/dalli#lib/dalli/client.rb:873 + # pkg:gem/dalli#lib/dalli/client.rb:943 def ttl_or_default(ttl); end # Raised before the request reaches a server: RequestFormatter enforces the @@ -594,7 +713,7 @@ class Dalli::Client # passing the wrong options should get a clean ArgumentError and keep its # connection. # - # pkg:gem/dalli#lib/dalli/client.rb:663 + # pkg:gem/dalli#lib/dalli/client.rb:730 def validate_delete_options!(req_options); end # Numeric arguments that become meta protocol flags (GHSA-6wmv-xq9m-fmp7). @@ -602,29 +721,29 @@ class Dalli::Client # checking here too gives the caller a clean ArgumentError for the same # reason as routing tokens, described below. # - # pkg:gem/dalli#lib/dalli/client.rb:811 + # pkg:gem/dalli#lib/dalli/client.rb:879 def validate_integer!(name, value); end - # pkg:gem/dalli#lib/dalli/client.rb:834 + # pkg:gem/dalli#lib/dalli/client.rb:902 def validate_routing_token!(name, value); end - # pkg:gem/dalli#lib/dalli/client.rb:827 + # pkg:gem/dalli#lib/dalli/client.rb:895 def validate_routing_tokens!(req_options); end - # pkg:gem/dalli#lib/dalli/client.rb:931 + # pkg:gem/dalli#lib/dalli/client.rb:1003 def warn_removed_options(opts); end end -# pkg:gem/dalli#lib/dalli/client.rb:592 +# pkg:gem/dalli#lib/dalli/client.rb:659 Dalli::Client::ALLOWED_STAT_KEYS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/client.rb:640 +# pkg:gem/dalli#lib/dalli/client.rb:707 Dalli::Client::CACHE_NILS = T.let(T.unsafe(nil), Hash) -# pkg:gem/dalli#lib/dalli/client.rb:641 +# pkg:gem/dalli#lib/dalli/client.rb:708 Dalli::Client::EMPTY_ATTRIBUTES = T.let(T.unsafe(nil), Hash) -# pkg:gem/dalli#lib/dalli/client.rb:924 +# pkg:gem/dalli#lib/dalli/client.rb:996 Dalli::Client::REMOVED_OPTIONS = T.let(T.unsafe(nil), Hash) # Validated here, before the request reaches Protocol::Base#request, rather @@ -633,7 +752,7 @@ Dalli::Client::REMOVED_OPTIONS = T.let(T.unsafe(nil), Hash) # failure as unexpected and closes the connection -- a caller passing a # bad token should get a clean ArgumentError and keep its connection. # -# pkg:gem/dalli#lib/dalli/client.rb:824 +# pkg:gem/dalli#lib/dalli/client.rb:892 Dalli::Client::ROUTING_TOKEN_FORBIDDEN = T.let(T.unsafe(nil), Regexp) # Default compressor used by Dalli, that uses @@ -642,14 +761,47 @@ Dalli::Client::ROUTING_TOKEN_FORBIDDEN = T.let(T.unsafe(nil), Regexp) # pkg:gem/dalli#lib/dalli/compressor.rb:11 class Dalli::Compressor class << self + # pkg:gem/dalli#lib/dalli/compressor.rb:59 + def append_within_limit(out, chunk, max_bytes); end + # pkg:gem/dalli#lib/dalli/compressor.rb:12 def compress(data); end - # pkg:gem/dalli#lib/dalli/compressor.rb:16 - def decompress(data); end + # max_bytes caps the decompressed size; inflating stops and raises as soon + # as the output passes it, so a small compressed value can't expand into + # gigabytes of memory. + # + # pkg:gem/dalli#lib/dalli/compressor.rb:26 + def decompress(data, max_bytes: T.unsafe(nil)); end + + # Both yielded and returned output count toward the limit + # + # pkg:gem/dalli#lib/dalli/compressor.rb:54 + def inflate_slice(inflater, slice, out, max_bytes); end + + # pkg:gem/dalli#lib/dalli/compressor.rb:38 + def inflate_within_limit(inflater, data, max_bytes); end + + # False when even the largest possible expansion stays within max_bytes, + # so the value can be inflated in one step + # + # pkg:gem/dalli#lib/dalli/compressor.rb:34 + def may_exceed?(data, max_bytes); end end end +# Compressed input is fed to zlib this many bytes at a time. MRI's zlib +# yields the output in small chunks; one that returns it instead still +# produces at most MAX_EXPANSION times this per step. +# +# pkg:gem/dalli#lib/dalli/compressor.rb:21 +Dalli::Compressor::INFLATE_SLICE_BYTES = T.let(T.unsafe(nil), Integer) + +# DEFLATE can't expand data by more than about 1032:1 +# +# pkg:gem/dalli#lib/dalli/compressor.rb:17 +Dalli::Compressor::MAX_EXPANSION = T.let(T.unsafe(nil), Integer) + # generic error # # pkg:gem/dalli#lib/dalli.rb:8 @@ -677,14 +829,14 @@ Dalli::Flags::UTF8 = T.let(T.unsafe(nil), Integer) # Gzip. Gzip adds a checksum to each compressed # entry. # -# pkg:gem/dalli#lib/dalli/compressor.rb:26 +# pkg:gem/dalli#lib/dalli/compressor.rb:72 class Dalli::GzipCompressor class << self - # pkg:gem/dalli#lib/dalli/compressor.rb:27 + # pkg:gem/dalli#lib/dalli/compressor.rb:73 def compress(data); end - # pkg:gem/dalli#lib/dalli/compressor.rb:35 - def decompress(data); end + # pkg:gem/dalli#lib/dalli/compressor.rb:81 + def decompress(data, max_bytes: T.unsafe(nil)); end end end @@ -834,6 +986,29 @@ end # pkg:gem/dalli#lib/dalli/instrumentation.rb:55 Dalli::Instrumentation::DEFAULT_ATTRIBUTES = T.let(T.unsafe(nil), Hash) +# A serializer that stores values as JSON and never creates Ruby objects +# from what it reads. +# +# Passing the JSON module itself as the serializer (serializer: JSON) reads +# values back with JSON.load, which on json gem versions before 3.0 honors +# "json_class" and instantiates other classes when the json gem's additions +# are loaded. This serializer reads with JSON.parse, so a value written to +# memcached by someone else can only come back as plain hashes, arrays, +# strings, numbers, booleans and nil. +# +# Dalli::Client.new(servers, serializer: Dalli::JSONSerializer) +# +# pkg:gem/dalli#lib/dalli/json_serializer.rb:19 +module Dalli::JSONSerializer + class << self + # pkg:gem/dalli#lib/dalli/json_serializer.rb:20 + def dump(value); end + + # pkg:gem/dalli#lib/dalli/json_serializer.rb:24 + def load(data); end + end +end + # This class manages and validates keys sent to Memcached, ensuring # that they meet Memcached key length requirements, and supporting # the implementation of optional namespaces on a per-Dalli client @@ -871,7 +1046,7 @@ class Dalli::KeyManager # pkg:gem/dalli#lib/dalli/key_manager.rb:30 def namespace_separator; end - # pkg:gem/dalli#lib/dalli/key_manager.rb:128 + # pkg:gem/dalli#lib/dalli/key_manager.rb:149 def prefix_length(digest); end # Produces a truncated key, if the raw key is longer than the maximum allowed @@ -899,6 +1074,14 @@ class Dalli::KeyManager # pkg:gem/dalli#lib/dalli/key_manager.rb:96 def validate_namespace_separator_option(opts); end + + # memcached's key limit applies to the key as sent: in bytes, and after + # base64 encoding when the key needs it. A key can be within the limit in + # characters and still be rejected, and memcached's CLIENT_ERROR for it + # must never reach a pipelined get. + # + # pkg:gem/dalli#lib/dalli/key_manager.rb:143 + def wire_length(key); end end # pkg:gem/dalli#lib/dalli/key_manager.rb:23 @@ -1168,13 +1351,13 @@ module Dalli::Protocol; end class Dalli::Protocol::Base extend ::Forwardable - # pkg:gem/dalli#lib/dalli/protocol/base.rb:39 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:40 def initialize(attribs, client_options = T.unsafe(nil)); end # Boolean method used by clients of this class to determine if this # particular memcached instance is available for use. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:95 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:109 def alive?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1192,22 +1375,22 @@ class Dalli::Protocol::Base # Delegated by hand rather than with def_delegators because they run on # every request, and a plain method call is cheaper than a Forwardable one. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:25 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:26 def connected?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def down!(*, **, &); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:30 def flushed_write(bytes); end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def hostname(*, **, &); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:116 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:130 def lock!; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:201 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:224 def multi?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1225,12 +1408,12 @@ class Dalli::Protocol::Base # # Returns nothing. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:181 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:201 def pipeline_abort; end # Did the last call to #pipeline_response_setup complete successfully? # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:194 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:217 def pipeline_complete?; end # Attempt to receive and parse as many key/value pairs as possible @@ -1242,7 +1425,7 @@ class Dalli::Protocol::Base # avoiding intermediate Hash allocation. Returns nil. # Without a block, returns a Hash of { key => [value, cas] }. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:141 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:155 def pipeline_next_responses(&block); end # Start reading key/value pairs from this connection. This is usually called @@ -1251,30 +1434,41 @@ class Dalli::Protocol::Base # # Returns nothing. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:125 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:139 def pipeline_response_setup; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def port(*, **, &); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:198 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:221 def quiet?; end + # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 + def quiet_responses_pending?(*, **, &); end + # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def raise_down_error(*, **, &); end # Returns true if client is in raw mode (no serialization/compression). # In raw mode, we can skip requesting bitflags from the server. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:50 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:52 def raw_mode?; end + # True when values should come back as stored: the client is in raw mode, + # or this request passed raw: true. Retrieval paths use it to skip + # requesting flags, so a stored value is never deserialized or + # decompressed for a caller who asked for raw bytes. + # + # pkg:gem/dalli#lib/dalli/protocol/base.rb:60 + def raw_request?(options); end + # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def reconnect_down_server?(*, **, &); end # Chokepoint method for error handling and ensuring liveness # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:55 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:65 def request(opkey, *args); end # pkg:gem/dalli#lib/dalli/protocol/base.rb:19 @@ -1283,7 +1477,7 @@ class Dalli::Protocol::Base # Written out rather than delegated: a multi-server get_multi calls it for # every server, and a plain method call is cheaper than a Forwardable one. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:35 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:36 def sock; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1292,7 +1486,7 @@ class Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def socket_type(*, **, &); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:118 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:132 def unlock!; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1309,17 +1503,23 @@ class Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/base.rb:263 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:294 def cache_nils?(opts); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:303 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:334 def connect; end + # With defer_drain, quiet blocks leave their replies unread. Read them + # before any non-quiet request, which reads a reply of its own. + # + # pkg:gem/dalli#lib/dalli/protocol/base.rb:245 + def drain_deferred_quiet_responses(opkey); end + # Non-blocking read and processing of any available pipeline responses. # Used during interleaved pipelined gets to prevent buffer deadlock. # Populates the provided results hash directly to avoid allocation overhead. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:346 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:379 def drain_pipeline_responses(results); end # The socket connection to the underlying server is initialized as a side @@ -1332,39 +1532,39 @@ class Dalli::Protocol::Base # Since this is invoked exclusively in verify_state!, we don't need to worry about # thread safety. Using it elsewhere may require revisiting that assumption. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:255 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:286 def ensure_connected!; end # Called after the noop response is received at the end of a set # of pipelined gets # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:373 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:406 def finish_pipeline; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:384 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:417 def log_marshal_err(key, err); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:389 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:422 def log_unexpected_err(err); end # return_cas = false leaves the c flag off each request, for callers # (plain get_multi) that discard the CAS value. It is positional because # #request forwards only positional arguments. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:312 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:343 def pipelined_get(keys, options = T.unsafe(nil), return_cas = T.unsafe(nil)); end # For large batches, interleave writing requests with draining responses. # This prevents socket buffer deadlock when sending many keys. # Populates the provided results hash with any responses drained during send. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:325 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:357 def pipelined_get_interleaved(keys, chunk_size, results, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:380 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:413 def reconnect_on_pipeline_complete!; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:367 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:400 def response_buffer; end # Extracts opaque routing-token kwargs (:p_token, :l_token) from a @@ -1374,10 +1574,10 @@ class Dalli::Protocol::Base # wire-formatter level, where it can raise uniformly regardless of how # the token reached the formatter. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:275 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:306 def routing_token_kwargs(opts); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:281 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:312 def routing_tokens?(opts); end # Maps the client-facing meta-delete options onto RequestFormatter's flag @@ -1389,29 +1589,29 @@ class Dalli::Protocol::Base # would allow emitting two T tokens in one request. It is sanitized like # every other TTL Dalli sends. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:293 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:324 def tombstone_kwargs(opts); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:220 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:251 def verify_allowed_quiet!(opkey); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:241 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:272 def verify_pipelined_state(_opkey); end # Checks to see if we can execute the specified operation. Checks # whether the connection is in use, and whether the command is allowed # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:230 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:261 def verify_state(opkey); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:211 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:234 def warn_uri_credentials(user_creds); end end -# pkg:gem/dalli#lib/dalli/protocol/base.rb:217 +# pkg:gem/dalli#lib/dalli/protocol/base.rb:240 Dalli::Protocol::Base::ALLOWED_QUIET_OPS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/base.rb:207 +# pkg:gem/dalli#lib/dalli/protocol/base.rb:230 Dalli::Protocol::Base::URI_CREDENTIAL_WARNING = T.let(T.unsafe(nil), String) # Compact the buffer when the consumed portion exceeds this @@ -1428,44 +1628,59 @@ class Dalli::Protocol::ConnectionManager # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:30 def initialize(hostname, port, socket_type, client_options); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:150 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:187 def abort_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:111 + # plus the value's trailing "\r\n" + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:207 + def check_read_size!(count); end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:162 + def clear_quiet_responses_pending!; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:119 def close; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:105 + # A forked child shares the parent's connection, so it closes only its + # own file descriptor. Closing the TLS socket itself would send + # close_notify and end the parent's TLS session. + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:143 + def close_socket; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:113 def confirm_in_progress!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:100 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:108 def confirm_ready!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:130 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:147 def connected?; end # Marks the server instance as down. Updates the down_at state # and raises an Dalli::NetworkError that includes the underlying # error in the message. Calls close to clean up socket state # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:83 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:89 def down!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:212 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:278 def error_on_request!(err_or_string); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:50 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:54 def establish_connection; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:144 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:176 def finish_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:188 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:253 def flush; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:194 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:259 def flushed_write(bytes); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:262 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:330 def fork_detected?; end # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 @@ -1474,22 +1689,25 @@ class Dalli::Protocol::ConnectionManager # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def hostname=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:266 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:334 def log_down_detected; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:278 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:346 def log_up_detected; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:247 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:314 def log_warn_message(err_or_string); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:208 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:158 + def mark_quiet_responses_pending!; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:274 def max_allowed_failures; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:239 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:306 def memcached_socket; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:42 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:46 def name; end # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 @@ -1504,46 +1722,56 @@ class Dalli::Protocol::ConnectionManager # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def port=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:92 + # True when a quiet request was written on this connection and its + # replies (memcached only suppresses some of them) haven't been + # consumed by a noop yet. + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:154 + def quiet_responses_pending?; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:100 def raise_down_error; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:171 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:222 def read(count); end # Non-blocking read. Here to support the operation # of the get_multi operation # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:204 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:269 def read_available(*, **, &); end # Alias for callers that want to make the exact-length contract explicit # at the call site. # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:180 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:233 def read_exact(count); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:154 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:191 def read_line; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:225 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:291 def reconnect!(message); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:62 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:68 def reconnect_down_server?; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:254 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:321 def reconnect_on_fork; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:134 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:166 def request_in_progress?; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:231 + # Called on connect. Deliberately leaves @fail_count alone; see + # finish_request!. + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:299 def reset_down_info; end # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:28 def sock; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:96 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:104 def socket_timeout; end # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 @@ -1552,17 +1780,30 @@ class Dalli::Protocol::ConnectionManager # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def socket_type=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:138 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:170 def start_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:75 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:81 def up!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:182 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:244 def write(bytes); end private + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:381 + def discard_write_buffer; end + + # One write per flush. A TLS socket sends each argument of + # write(*parts) as its own record and system call, so the parts are + # joined first. + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:358 + def flush_write_buffer; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:368 + def joined_write_buffer; end + # Reads exactly `count` bytes. IO#read(count) on a blocking socket blocks # until it has `count` bytes, accumulating across TCP chunks internally, # and only hands back a shorter (or nil) buffer when the stream hits EOF. @@ -1571,13 +1812,33 @@ class Dalli::Protocol::ConnectionManager # error_on_request!, which closes the dirty socket for a retry on a fresh # connection (and preserves the $ERROR_INFO context down! relies on). # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:294 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:393 def read_bytes(count); end end # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:14 Dalli::Protocol::ConnectionManager::DEFAULTS = T.let(T.unsafe(nil), Hash) +# JRuby doesn't support IO#timeout=, so use custom readfull implementation +# CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts +# memcached can't store an item larger than 1 GiB (its -I maximum), so a +# reply claiming more (or a negative size) is malformed or hostile. +# IO#read allocates the full count up front, so check before reading. +# +# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:205 +Dalli::Protocol::ConnectionManager::MAX_READ_BYTES = T.let(T.unsafe(nil), Integer) + +# Requests are buffered here rather than in the socket's own IO buffer +# (the socket is sync). Ruby flushes an IO's write buffer when any process +# holding it closes or finalizes the IO, so after a fork a child could +# send bytes the parent had buffered but not sent yet: a quiet write would +# run twice, or the parent's replies would shift onto the wrong requests. +# A forked child discards this buffer instead. Like IO's own buffer, it +# is sent once it grows past this size, or when a reply is read. +# +# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:242 +Dalli::Protocol::ConnectionManager::WRITE_BUFFER_FLUSH_BYTES = T.let(T.unsafe(nil), Integer) + # Access point for a single Memcached server, accessed via Memcached's meta # protocol. Contains logic for managing connection state to the server (retries, etc), # formatting requests to the server, and unpacking responses. @@ -1589,10 +1850,10 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:147 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:148 def add(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:169 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:175 def append(key, value, options = T.unsafe(nil)); end # TODO: This is confusing, as there's a cas command in memcached @@ -1603,10 +1864,10 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # Arithmetic Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:215 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:226 def decr(key, count, ttl, initial, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:224 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:235 def decr_incr(incr, key, delta, ttl, initial, options = T.unsafe(nil)); end # Delete Commands @@ -1614,13 +1875,13 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # `options` supports the meta-delete keys :invalidate, :tombstone_ttl and # :drop_value, plus :p_token/:l_token; see Dalli::Client#delete. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:193 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:199 def delete(key, cas, options = T.unsafe(nil)); end # Single-server fast path for delete_multi. Writes all quiet delete requests # terminated by a noop, then consumes all responses. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:355 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:381 def delete_multi_req(keys, req_options = T.unsafe(nil)); end # Delete with stale invalidation instead of actual deletion. @@ -1631,15 +1892,26 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # @param cas [Integer] optional CAS value for compare-and-swap # @return [Boolean] true if successful # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:129 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:130 def delete_stale(key, cas = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:209 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:220 def finish_pipelined_delete(sent); end + # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands. + # We need to read all the responses at once. + # A write that expects a reply is flushed so the reply can be read. A write + # in a quiet block stays buffered until the block's noop, unless + # defer_drain is on: then no noop follows at the end of the block, so it is + # flushed right away. (pipelined_set passes quiet: true outside a quiet + # block; its caller flushes with a terminating noop.) + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:257 + def finish_write(quiet); end + # Other Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:233 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:244 def flush(delay = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:57 @@ -1650,7 +1922,7 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/meta.rb:26 def get(key, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:219 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:230 def incr(key, count, ttl, initial, options = T.unsafe(nil)); end # Comprehensive meta get with support for all metadata flags. @@ -1678,31 +1950,31 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # - :hit_before - true/false if previously accessed (only if return_hit_status: true) # - :last_access - seconds since last access (only if return_last_access: true) # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:104 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:105 def meta_get(key, options = T.unsafe(nil)); end - # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands. - # We need to read all the responses at once. - # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:241 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:261 def noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:327 - def parse_multi_get_value(line, key_index, is_raw); end + # Reads the "VA [f] k ..." line in place rather than + # splitting it into tokens + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:353 + def parse_multi_get_value(line, is_raw); end # Pipelined delete - writes a quiet delete request without reading response. # Used by PipelinedDeleter for bulk operations. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:203 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:214 def pipelined_delete(key, req_options = T.unsafe(nil)); end # Pipelined set - writes a quiet set request without reading response. # Used by PipelinedSetter for bulk operations. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:143 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:144 def pipelined_set(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:174 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:180 def prepend(key, value, options = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:44 @@ -1714,20 +1986,20 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/meta.rb:52 def quiet_get_requests(keys, options = T.unsafe(nil), return_cas: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:314 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:339 def read_multi_get_responses(is_raw); end # Unlike read_multi_get_responses this locates tokens by flag rather than # by position, because the c flag shifts the key's index. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:295 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:318 def read_multi_metadata_responses(is_raw); end # Single-server fast path for get_multi. Inlines request formatting and # response parsing to minimize per-key overhead. Avoids the PipelinedGetter # machinery (IO.select, response buffering, server grouping). # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:268 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:291 def read_multi_req(keys, options = T.unsafe(nil)); end # Stale-aware bulk get. Returns { key => { value:, cas:, stale:, miss: } } @@ -1739,42 +2011,42 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # Shared by both the single-server fast path and PipelinedGetter's # per-server-group request, so this one change covers both routes. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:284 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:307 def read_multi_with_metadata_req(keys, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:152 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:153 def replace(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:251 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:274 def reset_stats; end # Storage Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:136 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:137 def set(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:246 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:269 def stats(info = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:65 def touch(key, ttl); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:256 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:279 def version; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:180 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:186 def write_append_prepend_req(mode, key, value, ttl = T.unsafe(nil), cas = T.unsafe(nil), options = T.unsafe(nil)); end # Single-server fast path for set_multi. Inlines request formatting to # minimize per-key overhead. Avoids PipelinedSetter server grouping. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:341 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:367 def write_multi_req(pairs, ttl, req_options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:261 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:284 def write_noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:157 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:158 def write_storage_req(mode, key, raw_value, ttl = T.unsafe(nil), cas = T.unsafe(nil), options = T.unsafe(nil), quiet: T.unsafe(nil)); end end @@ -1841,13 +2113,13 @@ Dalli::Protocol::Meta::KeyRegularizer::ASCII_CNTRL_OR_SPACE = T.let(T.unsafe(nil module Dalli::Protocol::Meta::RequestFormatter extend ::Dalli::Protocol::Meta::RequestFormatter - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:254 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:272 def encoded_key(key); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:237 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:255 def flush(delay: T.unsafe(nil), quiet: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:181 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:199 def meta_arithmetic(key:, delta:, initial:, incr: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), quiet: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end # Thundering herd protection flag: @@ -1863,7 +2135,7 @@ module Dalli::Protocol::Meta::RequestFormatter # - drop_value (x flag): remove the item's value but leave the item, so a # tombstone can be left without retaining the old payload. # - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:143 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:156 def meta_delete(key:, cas: T.unsafe(nil), ttl: T.unsafe(nil), quiet: T.unsafe(nil), stale: T.unsafe(nil), drop_value: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end # Since these are string construction methods, we're going to disable these @@ -1894,27 +2166,32 @@ module Dalli::Protocol::Meta::RequestFormatter # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:37 def meta_get(key:, value: T.unsafe(nil), return_cas: T.unsafe(nil), ttl: T.unsafe(nil), quiet: T.unsafe(nil), vivify_ttl: T.unsafe(nil), recache_ttl: T.unsafe(nil), return_hit_status: T.unsafe(nil), return_last_access: T.unsafe(nil), return_ttl_remaining: T.unsafe(nil), skip_lru_bump: T.unsafe(nil), skip_flags: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:229 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:247 def meta_noop; end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:90 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:103 def meta_set(key:, value:, bitflags: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), mode: T.unsafe(nil), quiet: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end # Tombstone and routing-token flags apply to every key in the batch; # see meta_delete. # - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:163 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:181 def multi_meta_delete(keys, stale: T.unsafe(nil), ttl: T.unsafe(nil), drop_value: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end # Pass terminate: false to leave off the trailing noop, for callers # (the pipelined get) that send it separately. # - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:68 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:81 def multi_meta_get(keys, skip_flags: T.unsafe(nil), return_cas: T.unsafe(nil), terminate: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:108 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:121 def multi_meta_set(entries, ttl: T.unsafe(nil), p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end + # Same bytes as meta_delete(key: key), without the keyword-argument handling + # + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:175 + def plain_meta_delete(key); end + # Fast path for the common single-key get with no optional flags. # Produces the same bytes as meta_get(key: key, skip_flags: skip_flags) # without the keyword-argument handling and incremental string building. @@ -1922,6 +2199,13 @@ module Dalli::Protocol::Meta::RequestFormatter # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:62 def plain_meta_get(key, skip_flags); end + # Fast path for a plain set: mode :set, not quiet, no CAS and no routing + # tokens. Produces the same bytes as meta_set(key:, value:, bitflags:, ttl:) + # without the keyword-argument handling and incremental string building. + # + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:69 + def plain_meta_set(key, value_bytesize, bitflags, ttl); end + # Builds the wire-format suffix for opaque routing tokens (P and L). # memcached itself ignores these; they exist as hints for a proxy or # router sitting between the client and memcached. See protocol.txt: @@ -1930,24 +2214,24 @@ module Dalli::Protocol::Meta::RequestFormatter # specifications to a proxy or router inbetween a client and a # memcached daemon." # - # Empty / nil tokens are treated as no-ops. CRLF and null bytes are - # rejected with ArgumentError to prevent the token from being used as a - # wire-protocol injection vector (e.g. "foo\r\nflush_all\r\n" would - # otherwise be parsed as a second command by memcached or any - # intermediate proxy/LB). + # Empty / nil tokens are treated as no-ops. Whitespace and control + # characters are rejected with ArgumentError so a token can't be used + # for wire-protocol injection: CRLF would add a second command (e.g. + # "foo\r\nflush_all\r\n"), and a space would add meta flags to this one + # (e.g. "foo T1" changing an item's TTL on a read). # - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:208 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:226 def routing_tokens(p_token: T.unsafe(nil), l_token: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:246 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:264 def stats(arg = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:233 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:251 def version; end private - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:301 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:322 def cas_string(cas); end # Numeric flag values are written straight into the command line, so a @@ -1956,29 +2240,30 @@ module Dalli::Protocol::Meta::RequestFormatter # means only digits ever reach the wire. Strings are parsed as base 10 so # "010" means 10, as memcached would read it, rather than octal 8. # - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:280 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:301 def integer_flag(name, value); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:286 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:307 def mode_to_token(mode); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:306 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:327 def parse_to_64_bit_int(val, default); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:269 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:288 def validate_routing_token!(name, value); end end -# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:244 +# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:262 Dalli::Protocol::Meta::RequestFormatter::ALLOWED_STATS_ARGS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:228 +# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:246 Dalli::Protocol::Meta::RequestFormatter::META_NOOP = T.let(T.unsafe(nil), String) -# Disallowed bytes: CR, LF, NUL. Any of these embedded in a routing -# token would let the caller inject a second wire-protocol command. +# Disallowed bytes: whitespace and control characters. CR, LF or NUL +# would let a token inject a second command; a space would let it add +# meta flags (T, N, I, q, ...) to the request it rides on. # -# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:266 +# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:285 Dalli::Protocol::Meta::RequestFormatter::ROUTING_TOKEN_FORBIDDEN = T.let(T.unsafe(nil), Regexp) # Class that encapsulates logic for processing meta protocol responses @@ -1987,37 +2272,54 @@ Dalli::Protocol::Meta::RequestFormatter::ROUTING_TOKEN_FORBIDDEN = T.let(T.unsaf # # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:11 class Dalli::Protocol::Meta::ResponseProcessor - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:44 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:49 def initialize(io_source, value_marshaller); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:279 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:388 + def base64_flag_in_line?(line); end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:362 def bitflags_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:289 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:372 def bitflags_from_va_line(line); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:107 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:115 def build_metadata_result(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:294 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:398 def cas_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:181 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:458 + def check_value_size!(size); end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:201 def consume_all_responses_until_mn; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:146 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:166 def decr_incr; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:265 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:348 def error_on_unexpected!(expected_codes); end + # Integer value of the first " " token at or after start, or 0 + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:393 + def flag_from_line(line, token_prefix, start); end + # Integer value of a flag token such as "f123", or 0 when absent. # Strips the prefix in place, like value_from_tokens. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:261 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:344 def flag_int(token, flag); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:164 + # Integer value of a flag's token in buf, after its one-byte prefix, + # as flag_int would read it + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:338 + def flag_int_at(buf, start, stop); end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:184 def flush; end # This method returns an array of values used in a pipelined @@ -2029,25 +2331,34 @@ class Dalli::Protocol::Meta::ResponseProcessor # The remaining three values in the array are the ResponseHeader, # key, and value. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:215 - def getk_response_from_buffer(buf, offset = T.unsafe(nil)); end + # raw: true returns values as stored, ignoring flags in the replies; + # see meta_get_with_value. + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:237 + def getk_response_from_buffer(buf, offset = T.unsafe(nil), raw: T.unsafe(nil)); end # Returns true if item was previously hit, false if first access, nil if not requested # The h flag returns h0 (first access) or h1 (previously accessed) # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:317 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:421 def hit_status_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:306 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:410 def key_from_tokens(tokens); end + # The key from a VA line's k flag, decoded when the line has the b flag, + # or nil when there is no k flag + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:378 + def key_from_va_line(line); end + # Returns seconds since last access, or nil if not requested # The l flag returns l # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:326 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:430 def last_access_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:141 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:155 def meta_delete; end # Returns a hash with all requested metadata: @@ -2062,29 +2373,33 @@ class Dalli::Protocol::Meta::ResponseProcessor # Used by meta_get for comprehensive metadata retrieval. # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u). # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:96 - def meta_get_with_metadata(cache_nils: T.unsafe(nil), return_hit_status: T.unsafe(nil), return_last_access: T.unsafe(nil), return_ttl_remaining: T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:104 + def meta_get_with_metadata(cache_nils: T.unsafe(nil), return_hit_status: T.unsafe(nil), return_last_access: T.unsafe(nil), return_ttl_remaining: T.unsafe(nil), raw: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:49 - def meta_get_with_value(cache_nils: T.unsafe(nil)); end + # raw: true (a request made with raw: true) returns the value as stored, + # ignoring any flags in the reply. The request didn't ask for flags, so + # a reply carrying them anyway must not get the value deserialized. + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:57 + def meta_get_with_value(cache_nils: T.unsafe(nil), raw: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:70 - def meta_get_with_value_and_cas; end + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:78 + def meta_get_with_value_and_cas(raw: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:80 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:88 def meta_get_without_value; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:134 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:148 def meta_set_append_prepend; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:127 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:135 def meta_set_with_cas; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:351 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:468 def next_line_to_tokens; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:120 - def parse_value_from_tokens(tokens, cache_nils); end + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:128 + def parse_value_from_tokens(tokens, cache_nils, raw = T.unsafe(nil)); end # Consumes the responses to a batch of quiet (pipelined) delete # requests, which are terminated by a noop (MN). In quiet mode @@ -2094,25 +2409,37 @@ class Dalli::Protocol::Meta::ResponseProcessor # callers can derive the number of successful deletes as # (keys_sent - non_deletions). # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:195 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:215 def pipelined_delete_non_deletions; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:273 - def raise_unexpected!(tokens); end + # A pipelined reply claiming an impossible size would otherwise have the + # buffer wait for (and accumulate) that many bytes + # The size given right after "VA", or 0 when it isn't a number + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:454 + def positional_size(tokens); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:356 + def raise_unexpected!(tokens); end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:473 def read_data(data_size); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:347 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:464 def read_line; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:170 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:190 def reset; end + # Values from a raw request are returned as stored + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:332 + def retrieve(value, bitflags, raw); end + # String#to_i stops at the first non-digit, so these read one token's # integer straight out of the header line without splitting it. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:285 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:368 def size_from_va_line(line); end # Detects the X presence flag, set when an item has been marked stale by a @@ -2120,40 +2447,51 @@ class Dalli::Protocol::Meta::ResponseProcessor # compares with ==) so a future value-bearing flag beginning with X cannot # be mistaken for it. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:302 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:406 def stale_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:154 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:174 def stats; end # Returns seconds of TTL remaining; -1 when the item has no expiry. # The t flag returns t. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:332 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:436 def ttl_remaining_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:336 + # getk_response_from_buffer for a "VA ..." header, read in place + # without allocating the header, its tokens or the flag strings. + # Gives the same result as the token path. Returns nil to fall back to + # it when the header has no s flag or a zero size. + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:300 + def va_response_from_buffer(buf, offset, term_idx, raw = T.unsafe(nil)); end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:440 def value_from_tokens(tokens, flag); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:176 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:196 def version; end end -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:28 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:33 Dalli::Protocol::Meta::ResponseProcessor::BYTE_B = T.let(T.unsafe(nil), Integer) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:29 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:34 Dalli::Protocol::Meta::ResponseProcessor::BYTE_C = T.let(T.unsafe(nil), Integer) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:30 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:35 Dalli::Protocol::Meta::ResponseProcessor::BYTE_F = T.let(T.unsafe(nil), Integer) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:31 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:36 Dalli::Protocol::Meta::ResponseProcessor::BYTE_K = T.let(T.unsafe(nil), Integer) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:32 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:37 Dalli::Protocol::Meta::ResponseProcessor::BYTE_S = T.let(T.unsafe(nil), Integer) +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:31 +Dalli::Protocol::Meta::ResponseProcessor::CAS_TOKEN_PREFIX = T.let(T.unsafe(nil), String) + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:12 Dalli::Protocol::Meta::ResponseProcessor::EN = T.let(T.unsafe(nil), String) @@ -2163,12 +2501,23 @@ Dalli::Protocol::Meta::ResponseProcessor::END_TOKEN = T.let(T.unsafe(nil), Strin # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:14 Dalli::Protocol::Meta::ResponseProcessor::EX = T.let(T.unsafe(nil), String) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:27 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:30 Dalli::Protocol::Meta::ResponseProcessor::FLAGS_TOKEN_PREFIX = T.let(T.unsafe(nil), String) # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:15 Dalli::Protocol::Meta::ResponseProcessor::HD = T.let(T.unsafe(nil), String) +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:29 +Dalli::Protocol::Meta::ResponseProcessor::HD_PREFIX = T.let(T.unsafe(nil), String) + +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:32 +Dalli::Protocol::Meta::ResponseProcessor::KEY_TOKEN_PREFIX = T.let(T.unsafe(nil), String) + +# memcached can't store an item larger than 1 GiB (its -I maximum) +# +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:28 +Dalli::Protocol::Meta::ResponseProcessor::MAX_VALUE_BYTES = T.let(T.unsafe(nil), Integer) + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:16 Dalli::Protocol::Meta::ResponseProcessor::MN = T.let(T.unsafe(nil), String) @@ -2190,31 +2539,31 @@ Dalli::Protocol::Meta::ResponseProcessor::SERVER_ERROR = T.let(T.unsafe(nil), St # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:21 Dalli::Protocol::Meta::ResponseProcessor::STAT = T.let(T.unsafe(nil), String) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:42 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:47 Dalli::Protocol::Meta::ResponseProcessor::T_END_TOKEN_STAT = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:36 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:41 Dalli::Protocol::Meta::ResponseProcessor::T_EN_HD = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:39 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:44 Dalli::Protocol::Meta::ResponseProcessor::T_HD_NF_EX = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:40 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:45 Dalli::Protocol::Meta::ResponseProcessor::T_HD_NS_NF_EX = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:34 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:39 Dalli::Protocol::Meta::ResponseProcessor::T_OK = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:35 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:40 Dalli::Protocol::Meta::ResponseProcessor::T_RESET = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:38 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:43 Dalli::Protocol::Meta::ResponseProcessor::T_VA_EN_HD = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:41 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:46 Dalli::Protocol::Meta::ResponseProcessor::T_VA_NF_NS_EX = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:37 +# pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:42 Dalli::Protocol::Meta::ResponseProcessor::T_VERSION = T.let(T.unsafe(nil), Array) # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:22 @@ -2240,37 +2589,42 @@ Dalli::Protocol::NOT_FOUND = T.let(T.unsafe(nil), Dalli::NilObject) # # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:17 class Dalli::Protocol::ResponseBuffer - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:18 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:21 def initialize(io_source, response_processor); end # Clear the internal response buffer # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:66 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:69 def clear; end # Ensures the buffer is initialized for reading without discarding # existing data. Used by interleaved pipelined get which may have # already buffered partial responses during the send phase. # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:58 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:61 def ensure_ready; end - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:72 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:75 def in_progress?; end # Attempts to process a single response from the buffer, # advancing the offset past the consumed bytes. # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:41 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:44 def process_single_getk_response; end - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:25 + # Whether the current pipeline was requested with raw: true + # + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:19 + def raw=(_arg0); end + + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:28 def read; end # Resets the internal buffer to an empty state, # so that we're ready to read pipelined responses # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:49 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:52 def reset; end end @@ -2423,10 +2777,10 @@ Dalli::Protocol::TtlSanitizer::MAX_ACCEPTABLE_EXPIRATION_INTERVAL = T.let(T.unsa # # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:13 class Dalli::Protocol::ValueCompressor - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:23 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:29 def initialize(client_options); end - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:47 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:74 def compress_by_default?; end # Checks whether we should apply compression when serializing a value @@ -2435,26 +2789,32 @@ class Dalli::Protocol::ValueCompressor # based on a method-level option if specified, falling back to the # server default. # - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:64 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:91 def compress_value?(value, req_options); end - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:55 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:82 def compression_min_size; end - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:51 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:78 def compressor; end - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:36 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:61 + def compressor_accepts_max_bytes?; end + + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:42 def retrieve(value, bitflags); end - # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:28 + # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:34 def store(value, req_options, bitflags); end end # pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:14 Dalli::Protocol::ValueCompressor::DEFAULTS = T.let(T.unsafe(nil), Hash) -# pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:21 +# pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:26 +Dalli::Protocol::ValueCompressor::KEYWORD_PARAMETER_TYPES = T.let(T.unsafe(nil), Array) + +# pkg:gem/dalli#lib/dalli/protocol/value_compressor.rb:24 Dalli::Protocol::ValueCompressor::OPTIONS = T.let(T.unsafe(nil), Array) # Dalli::Protocol::ValueMarshaller compartmentalizes the logic for marshalling @@ -2577,7 +2937,7 @@ class Dalli::Ring # pkg:gem/dalli#lib/dalli/ring.rb:27 def initialize(servers_arg, options); end - # pkg:gem/dalli#lib/dalli/ring.rb:103 + # pkg:gem/dalli#lib/dalli/ring.rb:111 def close; end # pkg:gem/dalli#lib/dalli/ring.rb:25 @@ -2586,22 +2946,30 @@ class Dalli::Ring # pkg:gem/dalli#lib/dalli/ring.rb:37 def continuum=(entries); end - # pkg:gem/dalli#lib/dalli/ring.rb:71 + # pkg:gem/dalli#lib/dalli/ring.rb:74 def keys_grouped_by_server(key_arr); end - # pkg:gem/dalli#lib/dalli/ring.rb:81 + # pkg:gem/dalli#lib/dalli/ring.rb:84 def lock; end - # pkg:gem/dalli#lib/dalli/ring.rb:90 + # Drains the replies left by quiet requests. Only servers that were sent a + # quiet request need it, so the others (and servers never connected) are + # skipped rather than each costing a noop round trip. + # + # pkg:gem/dalli#lib/dalli/ring.rb:96 def pipeline_consume_and_ignore_responses; end # alive_cache (optional) remembers each server's alive? result, so a # caller routing many keys checks each server once rather than per key. # - # pkg:gem/dalli#lib/dalli/ring.rb:46 + # pkg:gem/dalli#lib/dalli/ring.rb:47 def server_for_key(key, alive_cache = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/ring.rb:58 + # Tries the key's own server first, then (with failover) up to 19 + # rehashes of "". The first try is outside the loop because it + # is almost always the one that's used. + # + # pkg:gem/dalli#lib/dalli/ring.rb:62 def server_from_continuum(key, alive_cache = T.unsafe(nil)); end # this is the default in libmemcached @@ -2614,44 +2982,52 @@ class Dalli::Ring # pkg:gem/dalli#lib/dalli/ring.rb:24 def servers=(_arg0); end - # pkg:gem/dalli#lib/dalli/ring.rb:99 + # pkg:gem/dalli#lib/dalli/ring.rb:107 def socket_timeout; end private - # pkg:gem/dalli#lib/dalli/ring.rb:142 + # Hash values are 32 bits. Splitting that range into about one bucket per + # continuum entry, and noting the first entry at or after each bucket's + # start, lets server_for_hash_key skip the binary search: it starts at the + # key's bucket and steps over the few entries before the key's hash. + # + # pkg:gem/dalli#lib/dalli/ring.rb:144 + def build_buckets; end + + # pkg:gem/dalli#lib/dalli/ring.rb:169 def build_continuum(servers); end - # pkg:gem/dalli#lib/dalli/ring.rb:127 + # pkg:gem/dalli#lib/dalli/ring.rb:136 def entry_count_for(server, total_servers, total_weight); end - # pkg:gem/dalli#lib/dalli/ring.rb:115 + # pkg:gem/dalli#lib/dalli/ring.rb:123 def hash_for(key); end # Note that the call to alive? has the side effect of initializing # the socket # - # pkg:gem/dalli#lib/dalli/ring.rb:121 + # pkg:gem/dalli#lib/dalli/ring.rb:129 def server_alive?(server, alive_cache); end - # pkg:gem/dalli#lib/dalli/ring.rb:131 + # pkg:gem/dalli#lib/dalli/ring.rb:159 def server_for_hash_key(hash_key); end - # pkg:gem/dalli#lib/dalli/ring.rb:109 + # pkg:gem/dalli#lib/dalli/ring.rb:117 def threadsafe!; end end # Represents a point in the consistent hash ring implementation. # -# pkg:gem/dalli#lib/dalli/ring.rb:158 +# pkg:gem/dalli#lib/dalli/ring.rb:185 class Dalli::Ring::Entry - # pkg:gem/dalli#lib/dalli/ring.rb:161 + # pkg:gem/dalli#lib/dalli/ring.rb:188 def initialize(val, srv); end - # pkg:gem/dalli#lib/dalli/ring.rb:159 + # pkg:gem/dalli#lib/dalli/ring.rb:186 def server; end - # pkg:gem/dalli#lib/dalli/ring.rb:159 + # pkg:gem/dalli#lib/dalli/ring.rb:186 def value; end end @@ -2725,64 +3101,89 @@ module Dalli::Socket; end # # pkg:gem/dalli#lib/dalli/socket.rb:14 module Dalli::Socket::InstanceMethods - # pkg:gem/dalli#lib/dalli/socket.rb:44 + # Plain sockets keep nothing buffered in-process. See SSLSocket. + # + # pkg:gem/dalli#lib/dalli/socket.rb:57 + def buffered_data?; end + + # True when a read came back short and nothing is left buffered in-process. + # + # pkg:gem/dalli#lib/dalli/socket.rb:52 + def drained_after?(chunk); end + + # pkg:gem/dalli#lib/dalli/socket.rb:62 def logged_options; end - # pkg:gem/dalli#lib/dalli/socket.rb:15 + # Reads whatever is available without blocking. A read that returns less + # than a full chunk means the socket was drained, so we stop there rather + # than spend another read_nonblock call just to get :wait_readable back. + # Callers keep waiting on IO.select for anything that arrives later. + # + # pkg:gem/dalli#lib/dalli/socket.rb:21 def read_available(reusable_buffer = T.unsafe(nil)); end end -# pkg:gem/dalli#lib/dalli/socket.rb:43 +# pkg:gem/dalli#lib/dalli/socket.rb:61 Dalli::Socket::InstanceMethods::FILTERED_OUT_OPTIONS = T.let(T.unsafe(nil), Array) +# pkg:gem/dalli#lib/dalli/socket.rb:15 +Dalli::Socket::InstanceMethods::READ_CHUNK_SIZE = T.let(T.unsafe(nil), Integer) + # Wraps the below TCP socket class in the case where the client # has configured a TLS/SSL connection between Dalli and the # Memcached server. # -# pkg:gem/dalli#lib/dalli/socket.rb:79 +# pkg:gem/dalli#lib/dalli/socket.rb:97 class Dalli::Socket::SSLSocket < ::OpenSSL::SSL::SSLSocket include ::Dalli::Socket::InstanceMethods - # pkg:gem/dalli#lib/dalli/socket.rb:82 + # OpenSSL can hold decrypted bytes that IO.select won't report as readable. + # With OpenSSL's default (no read-ahead) a short read has already used up + # the current record, so this is normally 0; it guards read-ahead setups. + # + # pkg:gem/dalli#lib/dalli/socket.rb:107 + def buffered_data?; end + + # pkg:gem/dalli#lib/dalli/socket.rb:100 def options; end end # A standard TCP socket between the Dalli client and the Memcached server. # -# pkg:gem/dalli#lib/dalli/socket.rb:102 +# pkg:gem/dalli#lib/dalli/socket.rb:127 class Dalli::Socket::TCP < ::TCPSocket include ::Dalli::Socket::InstanceMethods # options - supports enhanced logging in the case of a timeout # - # pkg:gem/dalli#lib/dalli/socket.rb:106 + # pkg:gem/dalli#lib/dalli/socket.rb:131 def options; end # options - supports enhanced logging in the case of a timeout # - # pkg:gem/dalli#lib/dalli/socket.rb:106 + # pkg:gem/dalli#lib/dalli/socket.rb:131 def options=(_arg0); end class << self - # pkg:gem/dalli#lib/dalli/socket.rb:162 + # pkg:gem/dalli#lib/dalli/socket.rb:187 def configure_socket_buffers(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:157 + # pkg:gem/dalli#lib/dalli/socket.rb:182 def configure_tcp_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:167 + # pkg:gem/dalli#lib/dalli/socket.rb:192 def configure_timeout(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:139 + # pkg:gem/dalli#lib/dalli/socket.rb:164 def create_socket_with_timeout(host, port, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:151 + # pkg:gem/dalli#lib/dalli/socket.rb:176 def init_socket_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:114 + # pkg:gem/dalli#lib/dalli/socket.rb:139 def open(host, port, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/socket.rb:202 + # pkg:gem/dalli#lib/dalli/socket.rb:227 def pack_timeval(sock, seconds, microseconds); end # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument. @@ -2790,16 +3191,16 @@ class Dalli::Socket::TCP < ::TCPSocket # which forwards keyword arguments through its patch. # Returns false when monkey-patched by gems like socksify or resolv-replace < 0.2.0. # - # pkg:gem/dalli#lib/dalli/socket.rb:128 + # pkg:gem/dalli#lib/dalli/socket.rb:153 def supports_connect_timeout?; end # Detect and cache the correct pack format for struct timeval on this platform. # Different architectures have different sizes for time_t and suseconds_t. # - # pkg:gem/dalli#lib/dalli/socket.rb:195 + # pkg:gem/dalli#lib/dalli/socket.rb:220 def timeval_pack_format(sock); end - # pkg:gem/dalli#lib/dalli/socket.rb:206 + # pkg:gem/dalli#lib/dalli/socket.rb:231 def wrapping_ssl_socket(tcp_socket, host, ssl_context); end end end @@ -2808,7 +3209,7 @@ end # Used to detect when gems like socksify or resolv-replace have monkey-patched # TCPSocket, which breaks the connect_timeout: keyword argument. # -# pkg:gem/dalli#lib/dalli/socket.rb:111 +# pkg:gem/dalli#lib/dalli/socket.rb:136 Dalli::Socket::TCP::TCPSOCKET_NATIVE_PARAMETERS = T.let(T.unsafe(nil), Array) # Pack formats for struct timeval across architectures. @@ -2816,10 +3217,10 @@ Dalli::Socket::TCP::TCPSOCKET_NATIVE_PARAMETERS = T.let(T.unsafe(nil), Array) # - ll: 8 bytes (32-bit time_t, 32-bit suseconds_t) # - qq: 16 bytes (64-bit time_t, 64-bit suseconds_t or padded 32-bit) # -# pkg:gem/dalli#lib/dalli/socket.rb:189 +# pkg:gem/dalli#lib/dalli/socket.rb:214 Dalli::Socket::TCP::TIMEVAL_PACK_FORMATS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/socket.rb:190 +# pkg:gem/dalli#lib/dalli/socket.rb:215 Dalli::Socket::TCP::TIMEVAL_TEST_VALUES = T.let(T.unsafe(nil), Array) # UNIX domain sockets are not supported on Windows platforms. @@ -2829,27 +3230,27 @@ Dalli::Socket::TCP::TIMEVAL_TEST_VALUES = T.let(T.unsafe(nil), Array) # mechanism between processes on the same host. Used when the Memcached server # is running on the same machine as the Dalli client. # -# pkg:gem/dalli#lib/dalli/socket.rb:231 +# pkg:gem/dalli#lib/dalli/socket.rb:256 class Dalli::Socket::UNIX < ::UNIXSocket include ::Dalli::Socket::InstanceMethods # options - supports enhanced logging in the case of a timeout # server - used to support IO.select in the pipelined getter # - # pkg:gem/dalli#lib/dalli/socket.rb:236 + # pkg:gem/dalli#lib/dalli/socket.rb:261 def options; end # options - supports enhanced logging in the case of a timeout # server - used to support IO.select in the pipelined getter # - # pkg:gem/dalli#lib/dalli/socket.rb:236 + # pkg:gem/dalli#lib/dalli/socket.rb:261 def options=(_arg0); end class << self - # pkg:gem/dalli#lib/dalli/socket.rb:247 + # pkg:gem/dalli#lib/dalli/socket.rb:272 def init_socket_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:238 + # pkg:gem/dalli#lib/dalli/socket.rb:263 def open(path, options = T.unsafe(nil)); end end end diff --git a/sorbet/rbi/gems/graphql@2.6.11.rbi b/sorbet/rbi/gems/graphql@2.6.12.rbi similarity index 99% rename from sorbet/rbi/gems/graphql@2.6.11.rbi rename to sorbet/rbi/gems/graphql@2.6.12.rbi index 4ecde92ec..775f0c580 100644 --- a/sorbet/rbi/gems/graphql@2.6.11.rbi +++ b/sorbet/rbi/gems/graphql@2.6.12.rbi @@ -874,7 +874,7 @@ class GraphQL::Dataloader # @param index_by [Symbol] The attribute to use as the cache key. (Should match `find_by:` when using {ActiveRecordSource}) # @return [void] # - # pkg:gem/graphql#lib/graphql/dataloader.rb:279 + # pkg:gem/graphql#lib/graphql/dataloader.rb:281 def merge_records(records, index_by: T.unsafe(nil)); end # pkg:gem/graphql#lib/graphql/dataloader.rb:75 @@ -927,33 +927,33 @@ class GraphQL::Dataloader private - # pkg:gem/graphql#lib/graphql/dataloader.rb:339 + # pkg:gem/graphql#lib/graphql/dataloader.rb:341 def calculate_fiber_limit; end - # pkg:gem/graphql#lib/graphql/dataloader.rb:378 + # pkg:gem/graphql#lib/graphql/dataloader.rb:380 def dequeue_pending_source; end - # pkg:gem/graphql#lib/graphql/dataloader.rb:369 + # pkg:gem/graphql#lib/graphql/dataloader.rb:371 def drain_pending_sources; end # Returns true if anything was actually enqueued # - # pkg:gem/graphql#lib/graphql/dataloader.rb:292 + # pkg:gem/graphql#lib/graphql/dataloader.rb:294 def enqueue_next_pending_lazies(lazies_at_depth); end - # pkg:gem/graphql#lib/graphql/dataloader.rb:350 + # pkg:gem/graphql#lib/graphql/dataloader.rb:352 def join_queues(prev_queue, new_queue); end - # pkg:gem/graphql#lib/graphql/dataloader.rb:306 + # pkg:gem/graphql#lib/graphql/dataloader.rb:308 def run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit); end - # pkg:gem/graphql#lib/graphql/dataloader.rb:356 + # pkg:gem/graphql#lib/graphql/dataloader.rb:358 def spawn_job_fiber(trace); end - # pkg:gem/graphql#lib/graphql/dataloader.rb:385 + # pkg:gem/graphql#lib/graphql/dataloader.rb:387 def spawn_source_fiber(trace); end - # pkg:gem/graphql#lib/graphql/dataloader.rb:330 + # pkg:gem/graphql#lib/graphql/dataloader.rb:332 def with_trace_query_lazy(multiplex_or_nil, &block); end class << self @@ -1055,13 +1055,13 @@ class GraphQL::Dataloader::AsyncDataloader < ::GraphQL::Dataloader private - # pkg:gem/graphql#lib/graphql/dataloader/async_dataloader.rb:291 + # pkg:gem/graphql#lib/graphql/dataloader/async_dataloader.rb:293 def run_queue(run, condition, mode); end # Use a separate method for this so that the outer loop's reassignment of `pending_work` # doesn't affect already-running tasks which (would) close over that variable # - # pkg:gem/graphql#lib/graphql/dataloader/async_dataloader.rb:338 + # pkg:gem/graphql#lib/graphql/dataloader/async_dataloader.rb:340 def spawn_tasks(run, mode, condition, pending_work, num_tasks); end class << self @@ -1474,131 +1474,137 @@ end # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:4 class GraphQL::Execution::FieldResolveStep - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:5 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:9 def initialize(parent_type:, runner:, key:, selections_step:); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:108 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:112 def add_graphql_error(result, key, err, return_type: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:608 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:612 def add_non_null_error(is_from_array); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:386 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:390 def any_lazy_results?; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:40 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:44 def append_selection(ast_node); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def arguments; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def arguments=(_arg0); end # Used for compatibility in Schema::Subscription # - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:189 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:193 def arguments_without_loads; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def ast_node; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:36 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:40 def ast_nodes; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:601 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:605 def authorized_finished(step); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:169 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:173 def build_arguments; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:157 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:161 def build_errors_result(errors, single_error); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:510 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:514 def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:451 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:455 def build_results; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:82 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:86 def call; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:540 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:544 def enqueue_next_steps; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:196 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:200 def execute_field; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def field_definition; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def field_results; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:408 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:412 def finish_extensions; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:503 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:507 def finish_leaf_result(result_h, key, field_result, return_type, ctx); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def key; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def object_is_authorized; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def parent_type; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:32 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:36 def path; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def pending_steps; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def pending_steps=(_arg0); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:128 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:132 def propagate_nulls; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def runner; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def selections_step; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:617 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:621 def set_current_field(new_value = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def static_type; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:30 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:34 def static_type=(_arg0); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:64 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:68 def sync(lazy); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:51 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:55 def value; end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:27 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:31 def was_scoped; end private - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:623 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:627 def build_graphql_result(graphql_result, key, field_result, return_type, is_nn, is_list, is_from_array); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:799 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:810 def error_instance_array(size, err_prototype); end - # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:686 + # pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:697 def resolve_batch(objects, context, args_hash); end end +# Only these built-in fields on Relay connection and edge types return already-scoped items. +# Custom fields on those types must still be authorized normally. +# +# pkg:gem/graphql#lib/graphql/execution/field_resolve_step.rb:7 +GraphQL::Execution::FieldResolveStep::SCOPED_RELAY_FIELD_NAMES = T.let(T.unsafe(nil), Array) + # pkg:gem/graphql#lib/graphql/execution/finalize.rb:4 class GraphQL::Execution::Finalize # pkg:gem/graphql#lib/graphql/execution/finalize.rb:5 @@ -1897,13 +1903,13 @@ class GraphQL::Execution::Interpreter::Runtime # @param trace [Boolean] If `false`, don't wrap this with field tracing # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it. # - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:906 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:910 def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, runtime_state:, eager: T.unsafe(nil), trace: T.unsafe(nil), &block); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:960 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:964 def arguments(graphql_object, arg_owner, ast_node); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:814 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:818 def call_method_on_directives(method_name, object, directives, &block); end # @return [GraphQL::Query::Context] @@ -1920,7 +1926,7 @@ class GraphQL::Execution::Interpreter::Runtime # # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later # - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:659 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:661 def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state); end # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:552 @@ -1929,12 +1935,12 @@ class GraphQL::Execution::Interpreter::Runtime # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:540 def current_path; end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:969 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:973 def delete_all_interpreter_context; end # Check {Schema::Directive.include?} for each directive that's present # - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:853 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:857 def directives_include?(node, graphql_object, parent_type, selection_result, extra_path_part); end # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:199 @@ -1962,16 +1968,16 @@ class GraphQL::Execution::Interpreter::Runtime # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:212 def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:884 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:888 def get_current_runtime_state; end # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:62 def inspect; end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:1001 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:1005 def lazy?(object); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:889 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:893 def minimal_after_lazy(value, &block); end # @return [GraphQL::Query] @@ -1979,13 +1985,13 @@ class GraphQL::Execution::Interpreter::Runtime # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:30 def query; end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:799 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:801 def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:980 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:984 def resolve_type(type, value); end - # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:819 + # pkg:gem/graphql#lib/graphql/execution/interpreter/runtime.rb:823 def run_directive(method_name, object, directives, idx, &block); end # @return [void] @@ -5549,101 +5555,101 @@ class GraphQL::Language::Parser private - # pkg:gem/graphql#lib/graphql/language/parser.rb:97 + # pkg:gem/graphql#lib/graphql/language/parser.rb:98 def advance_token; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:803 + # pkg:gem/graphql#lib/graphql/language/parser.rb:804 def at?(expected_token_name); end # token_value works for when the scanner matched something # which is usually fine and it's good for it to be fast at that. # - # pkg:gem/graphql#lib/graphql/language/parser.rb:842 + # pkg:gem/graphql#lib/graphql/language/parser.rb:843 def debug_token_value; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:120 + # pkg:gem/graphql#lib/graphql/language/parser.rb:121 def definition; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:105 + # pkg:gem/graphql#lib/graphql/language/parser.rb:106 def document; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:814 + # pkg:gem/graphql#lib/graphql/language/parser.rb:815 def expect_one_of(token_names); end - # pkg:gem/graphql#lib/graphql/language/parser.rb:807 + # pkg:gem/graphql#lib/graphql/language/parser.rb:808 def expect_token(expected_token_name); end # Only use when we care about the expected token's value # - # pkg:gem/graphql#lib/graphql/language/parser.rb:831 + # pkg:gem/graphql#lib/graphql/language/parser.rb:832 def expect_token_value(tok); end - # @return [Array] Positions of each line break in the original string + # @return [Array] Byte offsets of each line break in the original string # # pkg:gem/graphql#lib/graphql/language/parser.rb:80 def lines_at; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:508 + # pkg:gem/graphql#lib/graphql/language/parser.rb:509 def list_type; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:460 + # pkg:gem/graphql#lib/graphql/language/parser.rb:461 def parse_argument_definitions; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:681 + # pkg:gem/graphql#lib/graphql/language/parser.rb:682 def parse_arguments; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:664 + # pkg:gem/graphql#lib/graphql/language/parser.rb:665 def parse_directives; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:385 + # pkg:gem/graphql#lib/graphql/language/parser.rb:386 def parse_enum_value_definitions; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:441 + # pkg:gem/graphql#lib/graphql/language/parser.rb:442 def parse_field_definitions; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:426 + # pkg:gem/graphql#lib/graphql/language/parser.rb:427 def parse_implements; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:371 + # pkg:gem/graphql#lib/graphql/language/parser.rb:372 def parse_input_object_field_definitions; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:474 + # pkg:gem/graphql#lib/graphql/language/parser.rb:475 def parse_input_value_definition; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:586 + # pkg:gem/graphql#lib/graphql/language/parser.rb:587 def parse_name; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:652 + # pkg:gem/graphql#lib/graphql/language/parser.rb:653 def parse_name_without_on; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:521 + # pkg:gem/graphql#lib/graphql/language/parser.rb:522 def parse_operation_type; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:660 + # pkg:gem/graphql#lib/graphql/language/parser.rb:661 def parse_type_name; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:409 + # pkg:gem/graphql#lib/graphql/language/parser.rb:410 def parse_union_members; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:101 + # pkg:gem/graphql#lib/graphql/language/parser.rb:102 def pos; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:818 + # pkg:gem/graphql#lib/graphql/language/parser.rb:819 def raise_parse_error(message); end - # pkg:gem/graphql#lib/graphql/language/parser.rb:535 + # pkg:gem/graphql#lib/graphql/language/parser.rb:536 def selection_set; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:701 + # pkg:gem/graphql#lib/graphql/language/parser.rb:702 def string_value; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:95 + # pkg:gem/graphql#lib/graphql/language/parser.rb:96 def token_name; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:491 + # pkg:gem/graphql#lib/graphql/language/parser.rb:492 def type; end - # pkg:gem/graphql#lib/graphql/language/parser.rb:707 + # pkg:gem/graphql#lib/graphql/language/parser.rb:708 def value; end class << self @@ -5661,9 +5667,9 @@ class GraphQL::Language::Parser end end -# pkg:gem/graphql#lib/graphql/language/parser.rb:845 +# pkg:gem/graphql#lib/graphql/language/parser.rb:846 class GraphQL::Language::Parser::SchemaParser < ::GraphQL::Language::Parser - # pkg:gem/graphql#lib/graphql/language/parser.rb:846 + # pkg:gem/graphql#lib/graphql/language/parser.rb:847 def initialize(*args, **kwargs); end end @@ -6849,33 +6855,33 @@ class GraphQL::Pagination::RelationConnection < ::GraphQL::Pagination::Connectio # @return [Integer, nil] # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:175 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:179 def after_offset; end - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:232 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:236 def async_dataloader?; end # @return [Integer, nil] # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:170 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:174 def before_offset; end - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:192 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:196 def build_limited_nodes; end - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:116 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:120 def calculate_sliced_nodes_parameters; end # Apply `first` and `last` to `sliced_nodes`, # returning a new relation # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:181 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:185 def limited_nodes; end # Load nodes after applying first/last/before/after, # returns an array of nodes # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:238 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:242 def load_nodes; end # @param relation [Object] A database query object @@ -6918,19 +6924,19 @@ class GraphQL::Pagination::RelationConnection < ::GraphQL::Pagination::Connectio # Abstract this operation so we can always ignore inputs less than zero. # (Sequel doesn't like it, understandably.) # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:106 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:110 def set_limit(relation, limit_value); end # Abstract this operation so we can always ignore inputs less than zero. # (Sequel doesn't like it, understandably.) # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:96 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:100 def set_offset(relation, offset_value); end # Apply `before` and `after` to the underlying `items`, # returning a new relation. # - # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:148 + # pkg:gem/graphql#lib/graphql/pagination/relation_connection.rb:152 def sliced_nodes; end end @@ -7946,7 +7952,7 @@ class GraphQL::Query::Variables # pkg:gem/graphql#lib/graphql/query/variables.rb:13 def initialize(ctx, ast_variables, provided_variables); end - # pkg:gem/graphql#lib/graphql/query/variables.rb:66 + # pkg:gem/graphql#lib/graphql/query/variables.rb:70 def [](*, **, &); end # pkg:gem/graphql#lib/graphql/query/variables.rb:11 @@ -7957,24 +7963,24 @@ class GraphQL::Query::Variables # pkg:gem/graphql#lib/graphql/query/variables.rb:9 def errors; end - # pkg:gem/graphql#lib/graphql/query/variables.rb:66 + # pkg:gem/graphql#lib/graphql/query/variables.rb:70 def fetch(*, **, &); end - # pkg:gem/graphql#lib/graphql/query/variables.rb:66 + # pkg:gem/graphql#lib/graphql/query/variables.rb:70 def key?(*, **, &); end - # pkg:gem/graphql#lib/graphql/query/variables.rb:66 + # pkg:gem/graphql#lib/graphql/query/variables.rb:70 def length(*, **, &); end - # pkg:gem/graphql#lib/graphql/query/variables.rb:66 + # pkg:gem/graphql#lib/graphql/query/variables.rb:70 def to_h(*, **, &); end private - # pkg:gem/graphql#lib/graphql/query/variables.rb:85 + # pkg:gem/graphql#lib/graphql/query/variables.rb:89 def add_max_errors_reached_message; end - # pkg:gem/graphql#lib/graphql/query/variables.rb:70 + # pkg:gem/graphql#lib/graphql/query/variables.rb:74 def deep_stringify(val); end end @@ -13865,55 +13871,55 @@ end # # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:15 class GraphQL::Schema::Visibility::Profile - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:63 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:82 def initialize(context:, schema:, visibility:, name: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:225 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:244 def all_types; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:230 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:249 def all_types_h; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:178 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:197 def argument(owner, arg_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:174 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:193 def arguments(owner); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:239 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:258 def directive_exists?(dir_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:243 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:262 def directives; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:235 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:254 def enum_values(owner); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:166 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:185 def field(owner, field_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:138 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:157 def field_on_visible_interface?(field, owner); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:170 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:189 def fields(owner); end # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:34 def freeze; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:205 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:224 def interfaces(obj_or_int_type); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:249 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:268 def loadable?(t, _ctx); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:253 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:272 def loadable_possible_types(t, _ctx); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:257 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:276 def loaded_types; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:217 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:236 def mutation_root; end # @return [Symbol, nil] @@ -13921,51 +13927,51 @@ class GraphQL::Schema::Visibility::Profile # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:32 def name; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:201 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:220 def possible_types(type); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:270 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:289 def preload; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:213 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:232 def query_root; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:261 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:280 def reachable_type?(type_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:221 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:240 def subscription_root; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:162 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:181 def type(type_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:266 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:285 def visible_enum_value?(enum_value, _ctx = T.unsafe(nil)); end private - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:345 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:387 def compute_field(owner, field_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:320 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:362 def compute_type(type_name); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:393 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:435 def load_all_types; end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:374 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:416 def non_duplicate_items(definitions, visibility_cache); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:432 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:474 def possible_types_for(type); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:389 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:431 def raise_duplicate_definition(first_defn, second_defn); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:417 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:459 def referenced?(type_defn); end - # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:466 + # pkg:gem/graphql#lib/graphql/schema/visibility/profile.rb:508 def visible_field_for(owner, field); end class << self @@ -14521,17 +14527,17 @@ class GraphQL::StaticValidation::BaseVisitor < ::GraphQL::Language::StaticVisito # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:5 def initialize(document, context); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:22 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:23 def context; end # @return [Array] The nesting of the current position in the AST # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:25 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:26 def path; end private - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:215 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:225 def add_error(error, path: T.unsafe(nil)); end class << self @@ -14540,64 +14546,67 @@ class GraphQL::StaticValidation::BaseVisitor < ::GraphQL::Language::StaticVisito # @param rules [Array] # @return [Class] A class for validating `rules` during visitation # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:33 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:34 def including_rules(rules); end end end -# pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:56 +# pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:57 module GraphQL::StaticValidation::BaseVisitor::ContextMethods # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:204 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:214 def argument_definition; end + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:185 + def child_positions(parent); end + # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:199 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:209 def directive_definition; end # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:194 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:204 def field_definition; end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:137 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:138 def on_argument(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:129 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:130 def on_directive(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:108 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:109 def on_field(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:70 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:71 def on_fragment_definition(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:164 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:166 def on_fragment_spread(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:89 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:90 def on_inline_fragment(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:171 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:173 def on_input_object(node, parent); end - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:57 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:58 def on_operation_definition(node, parent); end # @return [GraphQL::BaseType] The type which the current type came from # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:189 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:199 def parent_type_definition; end # @return [GraphQL::BaseType] The current object type # - # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:184 + # pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:194 def type_definition; end end -# pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:87 +# pkg:gem/graphql#lib/graphql/static_validation/base_visitor.rb:88 GraphQL::StaticValidation::BaseVisitor::ContextMethods::INLINE_FRAGMENT_NO_TYPE = T.let(T.unsafe(nil), String) # Track fragment dependencies for operations @@ -15643,6 +15652,11 @@ end module GraphQL::StaticValidation::SubscriptionRootExistsAndSingleSubscriptionSelection # pkg:gem/graphql#lib/graphql/static_validation/rules/subscription_root_exists_and_single_subscription_selection.rb:5 def on_operation_definition(node, parent); end + + private + + # pkg:gem/graphql#lib/graphql/static_validation/rules/subscription_root_exists_and_single_subscription_selection.rb:34 + def subscription_root_fields(node); end end # pkg:gem/graphql#lib/graphql/static_validation/rules/subscription_root_exists_error.rb:4 diff --git a/sorbet/rbi/gems/json@2.21.2.rbi b/sorbet/rbi/gems/json@2.21.2.rbi deleted file mode 100644 index 85e9c19e9..000000000 --- a/sorbet/rbi/gems/json@2.21.2.rbi +++ /dev/null @@ -1,2338 +0,0 @@ -# typed: false - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `json` gem. -# Please instead update this file by running `bin/tapioca gem json`. - - -# = JavaScript \Object Notation (\JSON) -# -# \JSON is a lightweight data-interchange format. -# -# \JSON is easy for us humans to read and write, -# and equally simple for machines to read (parse) and write (generate). -# -# \JSON is language-independent, making it an ideal interchange format -# for applications in differing programming languages -# and on differing operating systems. -# -# == \JSON Values -# -# A \JSON value is one of the following: -# - Double-quoted text: "foo". -# - Number: +1+, +1.0+, +2.0e2+. -# - Boolean: +true+, +false+. -# - Null: +null+. -# - \Array: an ordered list of values, enclosed by square brackets: -# ["foo", 1, 1.0, 2.0e2, true, false, null] -# -# - \Object: a collection of name/value pairs, enclosed by curly braces; -# each name is double-quoted text; -# the values may be any \JSON values: -# {"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null} -# -# A \JSON array or object may contain nested arrays, objects, and scalars -# to any depth: -# {"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]} -# [{"foo": 0, "bar": 1}, ["baz", 2]] -# -# == Using \Module \JSON -# -# To make module \JSON available in your code, begin with: -# require 'json' -# -# All examples here assume that this has been done. -# -# === Parsing \JSON -# -# You can parse a \String containing \JSON data using -# either of two methods: -# - JSON.parse(source, opts) -# - JSON.parse!(source, opts) -# -# where -# - +source+ is a Ruby object. -# - +opts+ is a \Hash object containing options -# that control both input allowed and output formatting. -# -# The difference between the two methods -# is that JSON.parse! omits some checks -# and may not be safe for some +source+ data; -# use it only for data from trusted sources. -# Use the safer method JSON.parse for less trusted sources. -# -# ==== Parsing \JSON Arrays -# -# When +source+ is a \JSON array, JSON.parse by default returns a Ruby \Array: -# json = '["foo", 1, 1.0, 2.0e2, true, false, null]' -# ruby = JSON.parse(json) -# ruby # => ["foo", 1, 1.0, 200.0, true, false, nil] -# ruby.class # => Array -# -# The \JSON array may contain nested arrays, objects, and scalars -# to any depth: -# json = '[{"foo": 0, "bar": 1}, ["baz", 2]]' -# JSON.parse(json) # => [{"foo"=>0, "bar"=>1}, ["baz", 2]] -# -# ==== Parsing \JSON \Objects -# -# When the source is a \JSON object, JSON.parse by default returns a Ruby \Hash: -# json = '{"a": "foo", "b": 1, "c": 1.0, "d": 2.0e2, "e": true, "f": false, "g": null}' -# ruby = JSON.parse(json) -# ruby # => {"a"=>"foo", "b"=>1, "c"=>1.0, "d"=>200.0, "e"=>true, "f"=>false, "g"=>nil} -# ruby.class # => Hash -# -# The \JSON object may contain nested arrays, objects, and scalars -# to any depth: -# json = '{"foo": {"bar": 1, "baz": 2}, "bat": [0, 1, 2]}' -# JSON.parse(json) # => {"foo"=>{"bar"=>1, "baz"=>2}, "bat"=>[0, 1, 2]} -# -# ==== Parsing \JSON Scalars -# -# When the source is a \JSON scalar (not an array or object), -# JSON.parse returns a Ruby scalar. -# -# \String: -# ruby = JSON.parse('"foo"') -# ruby # => 'foo' -# ruby.class # => String -# \Integer: -# ruby = JSON.parse('1') -# ruby # => 1 -# ruby.class # => Integer -# \Float: -# ruby = JSON.parse('1.0') -# ruby # => 1.0 -# ruby.class # => Float -# ruby = JSON.parse('2.0e2') -# ruby # => 200 -# ruby.class # => Float -# Boolean: -# ruby = JSON.parse('true') -# ruby # => true -# ruby.class # => TrueClass -# ruby = JSON.parse('false') -# ruby # => false -# ruby.class # => FalseClass -# Null: -# ruby = JSON.parse('null') -# ruby # => nil -# ruby.class # => NilClass -# -# ==== Parsing Options -# -# ====== Input Options -# -# Option +max_nesting+ (\Integer) specifies the maximum nesting depth allowed; -# defaults to +100+; -# You can set it to +false+ to disable depth checking entirely, but that is dangerous -# when parsing untrusted input. -# -# With the default, +100+: -# source = '[0, [1, [2, [3]]]]' -# ruby = JSON.parse(source) -# ruby # => [0, [1, [2, [3]]]] -# Too deep: -# # Raises JSON::NestingError (nesting of 2 is too deep): -# JSON.parse(source, {max_nesting: 1}) -# Bad value: -# # Raises TypeError (wrong argument type Symbol (expected Fixnum)): -# JSON.parse(source, {max_nesting: :foo}) -# -# --- -# -# Option +allow_duplicate_key+ specifies whether duplicate keys in objects -# should be ignored or cause an error to be raised: -# -# When not specified: -# # The last value is used and a deprecation warning emitted. -# JSON.parse('{"a": 1, "a":2}') => {"a" => 2} -# # warning: detected duplicate keys in JSON object. -# # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true` -# -# When set to +true+: -# # The last value is used. -# JSON.parse('{"a": 1, "a":2}') => {"a" => 2} -# -# When set to +false+, the future default: -# JSON.parse('{"a": 1, "a":2}') => duplicate key at line 1 column 1 (JSON::ParserError) -# -# --- -# -# Option +allow_nan+ (boolean) specifies whether to allow -# NaN, Infinity, and MinusInfinity in +source+; -# defaults to +false+. -# -# With the default, +false+: -# # Raises JSON::ParserError (225: unexpected token at '[NaN]'): -# JSON.parse('[NaN]') -# # Raises JSON::ParserError (232: unexpected token at '[Infinity]'): -# JSON.parse('[Infinity]') -# # Raises JSON::ParserError (248: unexpected token at '[-Infinity]'): -# JSON.parse('[-Infinity]') -# Allow: -# source = '[NaN, Infinity, -Infinity]' -# ruby = JSON.parse(source, {allow_nan: true}) -# ruby # => [NaN, Infinity, -Infinity] -# -# --- -# -# Option +allow_trailing_comma+ (boolean) specifies whether to allow -# trailing commas in objects and arrays; -# defaults to +false+. -# -# With the default, +false+: -# JSON.parse('[1,]') # unexpected character: ']' at line 1 column 4 (JSON::ParserError) -# -# When enabled: -# JSON.parse('[1,]', allow_trailing_comma: true) # => [1] -# -# --- -# -# Option +allow_comments+ (boolean) specifies whether to allow -# JavaScript style comments (either // comment or /* comment */); -# defaults to +false+. -# -# When not specified, a deprecation warning is emitted if a comment is encountered. -# -# When set to +true+, comments are ignored: -# JSON.parse('/* comment */ {"a": 1, "a":2}') # => {"a" => 2} -# -# When set to +false+, the future default: -# JSON.parse('/* comment */ {"a": 1, "a":2}') # unexpected character: '/' at line 1 column 1 (JSON::ParserError) -# -# --- -# -# Option +allow_control_characters+ (boolean) specifies whether to allow -# unescaped ASCII control characters, such as newlines, in strings; -# defaults to +false+. -# -# With the default, +false+: -# JSON.parse(%{"Hello\nWorld"}) # invalid ASCII control character in string (JSON::ParserError) -# -# When enabled: -# JSON.parse(%{"Hello\nWorld"}, allow_control_characters: true) # => "Hello\nWorld" -# -# --- -# -# Option +allow_invalid_escape+ (boolean) specifies whether to ignore backslahes that are followed -# by an invalid escape character in strings; -# defaults to +false+. -# -# With the default, +false+: -# JSON.parse('"Hell\o"') # invalid escape character in string (JSON::ParserError) -# -# When enabled: -# JSON.parse('"Hell\o"', allow_invalid_escape: true) # => "Hello" -# -# ====== Output Options -# -# Option +freeze+ (boolean) specifies whether the returned objects will be frozen; -# defaults to +false+. -# -# Option +symbolize_names+ (boolean) specifies whether returned \Hash keys -# should be Symbols; -# defaults to +false+ (use Strings). -# -# With the default, +false+: -# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' -# ruby = JSON.parse(source) -# ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} -# Use Symbols: -# ruby = JSON.parse(source, {symbolize_names: true}) -# ruby # => {:a=>"foo", :b=>1.0, :c=>true, :d=>false, :e=>nil} -# -# --- -# -# Option +object_class+ (\Class) specifies the Ruby class to be used -# for each \JSON object; -# defaults to \Hash. -# -# With the default, \Hash: -# source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' -# ruby = JSON.parse(source) -# ruby.class # => Hash -# Use class \OpenStruct: -# ruby = JSON.parse(source, {object_class: OpenStruct}) -# ruby # => # -# -# --- -# -# Option +array_class+ (\Class) specifies the Ruby class to be used -# for each \JSON array; -# defaults to \Array. -# -# With the default, \Array: -# source = '["foo", 1.0, true, false, null]' -# ruby = JSON.parse(source) -# ruby.class # => Array -# Use class \Set: -# ruby = JSON.parse(source, {array_class: Set}) -# ruby # => # -# -# --- -# -# Option +create_additions+ (boolean) specifies whether to use \JSON additions in parsing. -# See {\JSON Additions}[#module-JSON-label-JSON+Additions]. -# -# === Generating \JSON -# -# To generate a Ruby \String containing \JSON data, -# use method JSON.generate(source, opts), where -# - +source+ is a Ruby object. -# - +opts+ is a \Hash object containing options -# that control both input allowed and output formatting. -# -# ==== Generating \JSON from Arrays -# -# When the source is a Ruby \Array, JSON.generate returns -# a \String containing a \JSON array: -# ruby = [0, 's', :foo] -# json = JSON.generate(ruby) -# json # => '[0,"s","foo"]' -# -# The Ruby \Array array may contain nested arrays, hashes, and scalars -# to any depth: -# ruby = [0, [1, 2], {foo: 3, bar: 4}] -# json = JSON.generate(ruby) -# json # => '[0,[1,2],{"foo":3,"bar":4}]' -# -# ==== Generating \JSON from Hashes -# -# When the source is a Ruby \Hash, JSON.generate returns -# a \String containing a \JSON object: -# ruby = {foo: 0, bar: 's', baz: :bat} -# json = JSON.generate(ruby) -# json # => '{"foo":0,"bar":"s","baz":"bat"}' -# -# The Ruby \Hash array may contain nested arrays, hashes, and scalars -# to any depth: -# ruby = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} -# json = JSON.generate(ruby) -# json # => '{"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"}' -# -# ==== Generating \JSON from Other Objects -# -# When the source is neither an \Array nor a \Hash, -# the generated \JSON data depends on the class of the source. -# -# When the source is a Ruby \Integer or \Float, JSON.generate returns -# a \String containing a \JSON number: -# JSON.generate(42) # => '42' -# JSON.generate(0.42) # => '0.42' -# -# When the source is a Ruby \String, JSON.generate returns -# a \String containing a \JSON string (with double-quotes): -# JSON.generate('A string') # => '"A string"' -# -# When the source is +true+, +false+ or +nil+, JSON.generate returns -# a \String containing the corresponding \JSON token: -# JSON.generate(true) # => 'true' -# JSON.generate(false) # => 'false' -# JSON.generate(nil) # => 'null' -# -# When the source is none of the above, JSON.generate returns -# a \String containing a \JSON string representation of the source: -# JSON.generate(:foo) # => '"foo"' -# JSON.generate(Complex(0, 0)) # => '"0+0i"' -# JSON.generate(Dir.new('.')) # => '"#"' -# -# ==== Generating Options -# -# ====== Input Options -# -# Option +allow_nan+ (boolean) specifies whether -# +NaN+, +Infinity+, and -Infinity may be generated; -# defaults to +false+. -# -# With the default, +false+: -# # Raises JSON::GeneratorError (920: NaN not allowed in JSON): -# JSON.generate(JSON::NaN) -# # Raises JSON::GeneratorError (917: Infinity not allowed in JSON): -# JSON.generate(JSON::Infinity) -# # Raises JSON::GeneratorError (917: -Infinity not allowed in JSON): -# JSON.generate(JSON::MinusInfinity) -# -# Allow: -# ruby = [Float::NAN, Float::INFINITY, JSON::NaN, JSON::Infinity, JSON::MinusInfinity] -# JSON.generate(ruby, allow_nan: true) # => '[NaN,Infinity,NaN,Infinity,-Infinity]' -# -# --- -# -# Option +allow_duplicate_key+ (boolean) specifies whether -# hashes with duplicate keys should be allowed or produce an error. -# defaults to emit a deprecation warning. -# -# With the default, (not set): -# Warning[:deprecated] = true -# JSON.generate({ foo: 1, "foo" => 2 }) -# # warning: detected duplicate key "foo" in {foo: 1, "foo" => 2}. -# # This will raise an error in json 3.0 unless enabled via `allow_duplicate_key: true` -# # => '{"foo":1,"foo":2}' -# -# With false -# JSON.generate({ foo: 1, "foo" => 2 }, allow_duplicate_key: false) -# # detected duplicate key "foo" in {foo: 1, "foo" => 2} (JSON::GeneratorError) -# -# In version 3.0, false will become the default. -# -# --- -# -# Option +max_nesting+ (\Integer) specifies the maximum nesting depth -# in +obj+; defaults to +100+. -# -# With the default, +100+: -# obj = [[[[[[0]]]]]] -# JSON.generate(obj) # => '[[[[[[0]]]]]]' -# -# Too deep: -# # Raises JSON::NestingError (nesting of 2 is too deep): -# JSON.generate(obj, max_nesting: 2) -# -# With +false+: -# obj = [] -# obj[0] = obj -# # Raises SystemStackError: stack level too deep -# JSON.generate(obj, max_nesting: false) -# -# Setting +max_nesting+ to +false+ can lead to a stackoverflow and may leave the program -# in an unrecoverable state. It is discouraged. -# -# ====== Escaping Options -# -# Options +script_safe+ (boolean) specifies wether '\u2028', '\u2029' -# and '/' should be escaped as to make the JSON object safe to interpolate in script -# tags. -# -# Options +ascii_only+ (boolean) specifies wether all characters outside the ASCII range -# should be escaped. -# -# ====== Output Options -# -# The default formatting options generate the most compact -# \JSON data, all on one line and with no whitespace. -# -# You can use these formatting options to generate -# \JSON data in a more open format, using whitespace. -# See also JSON.pretty_generate. -# -# - Option +array_nl+ (\String) specifies a string (usually a newline) -# to be inserted after each \JSON array; defaults to the empty \String, ''. -# - Option +object_nl+ (\String) specifies a string (usually a newline) -# to be inserted after each \JSON object; defaults to the empty \String, ''. -# - Option +indent+ (\String) specifies the string (usually spaces) to be -# used for indentation; defaults to the empty \String, ''; -# has no effect unless options +array_nl+ or +object_nl+ specify newlines. -# - Option +space+ (\String) specifies a string (usually a space) to be -# inserted after the colon in each \JSON object's pair; -# defaults to the empty \String, ''. -# - Option +space_before+ (\String) specifies a string (usually a space) to be -# inserted before the colon in each \JSON object's pair; -# defaults to the empty \String, ''. -# - Option +sort_keys+ (boolean or \Proc) controls whether and how the keys of a -# hash are sorted when generating the output; defaults to false. -# When +true+, keys are sorted lexicographically. When a \Proc, it receives -# the entire \Hash and must return a \Hash with its pairs in the desired -# order, allowing for arbitrary sort orders. -# -# In this example, +obj+ is used first to generate the shortest -# \JSON data (no whitespace), then again with all formatting options -# specified: -# -# obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} -# json = JSON.generate(obj) -# puts 'Compact:', json -# opts = { -# array_nl: "\n", -# object_nl: "\n", -# indent: ' ', -# space_before: ' ', -# space: ' ' -# } -# puts 'Open:', JSON.generate(obj, opts) -# -# Output: -# Compact: -# {"foo":["bar","baz"],"bat":{"bam":0,"bad":1}} -# Open: -# { -# "foo" : [ -# "bar", -# "baz" -# ], -# "bat" : { -# "bam" : 0, -# "bad" : 1 -# } -# } -# -# == \JSON Additions -# -# Note that JSON Additions must only be used with trusted data, and is -# deprecated. -# -# When you "round trip" a non-\String object from Ruby to \JSON and back, -# you have a new \String, instead of the object you began with: -# ruby0 = Range.new(0, 2) -# json = JSON.generate(ruby0) -# json # => '0..2"' -# ruby1 = JSON.parse(json) -# ruby1 # => '0..2' -# ruby1.class # => String -# -# You can use \JSON _additions_ to preserve the original object. -# The addition is an extension of a ruby class, so that: -# - \JSON.generate stores more information in the \JSON string. -# - \JSON.parse, called with option +create_additions+, -# uses that information to create a proper Ruby object. -# -# This example shows a \Range being generated into \JSON -# and parsed back into Ruby, both without and with -# the addition for \Range: -# ruby = Range.new(0, 2) -# # This passage does not use the addition for Range. -# json0 = JSON.generate(ruby) -# ruby0 = JSON.parse(json0) -# # This passage uses the addition for Range. -# require 'json/add/range' -# json1 = JSON.generate(ruby) -# ruby1 = JSON.parse(json1, create_additions: true) -# # Make a nice display. -# display = <<~EOT -# Generated JSON: -# Without addition: #{json0} (#{json0.class}) -# With addition: #{json1} (#{json1.class}) -# Parsed JSON: -# Without addition: #{ruby0.inspect} (#{ruby0.class}) -# With addition: #{ruby1.inspect} (#{ruby1.class}) -# EOT -# puts display -# -# This output shows the different results: -# Generated JSON: -# Without addition: "0..2" (String) -# With addition: {"json_class":"Range","a":[0,2,false]} (String) -# Parsed JSON: -# Without addition: "0..2" (String) -# With addition: 0..2 (Range) -# -# The \JSON module includes additions for certain classes. -# You can also craft custom additions. -# See {Custom \JSON Additions}[#module-JSON-label-Custom+JSON+Additions]. -# -# === Built-in Additions -# -# The \JSON module includes additions for certain classes. -# To use an addition, +require+ its source: -# - BigDecimal: require 'json/add/bigdecimal' -# - Complex: require 'json/add/complex' -# - Date: require 'json/add/date' -# - DateTime: require 'json/add/date_time' -# - Exception: require 'json/add/exception' -# - OpenStruct: require 'json/add/ostruct' -# - Range: require 'json/add/range' -# - Rational: require 'json/add/rational' -# - Regexp: require 'json/add/regexp' -# - Set: require 'json/add/set' -# - Struct: require 'json/add/struct' -# - Symbol: require 'json/add/symbol' -# - Time: require 'json/add/time' -# -# To reduce punctuation clutter, the examples below -# show the generated \JSON via +puts+, rather than the usual +inspect+, -# -# \BigDecimal: -# require 'json/add/bigdecimal' -# ruby0 = BigDecimal(0) # 0.0 -# json = JSON.generate(ruby0) # {"json_class":"BigDecimal","b":"27:0.0"} -# ruby1 = JSON.parse(json, create_additions: true) # 0.0 -# ruby1.class # => BigDecimal -# -# \Complex: -# require 'json/add/complex' -# ruby0 = Complex(1+0i) # 1+0i -# json = JSON.generate(ruby0) # {"json_class":"Complex","r":1,"i":0} -# ruby1 = JSON.parse(json, create_additions: true) # 1+0i -# ruby1.class # Complex -# -# \Date: -# require 'json/add/date' -# ruby0 = Date.today # 2020-05-02 -# json = JSON.generate(ruby0) # {"json_class":"Date","y":2020,"m":5,"d":2,"sg":2299161.0} -# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 -# ruby1.class # Date -# -# \DateTime: -# require 'json/add/date_time' -# ruby0 = DateTime.now # 2020-05-02T10:38:13-05:00 -# json = JSON.generate(ruby0) # {"json_class":"DateTime","y":2020,"m":5,"d":2,"H":10,"M":38,"S":13,"of":"-5/24","sg":2299161.0} -# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02T10:38:13-05:00 -# ruby1.class # DateTime -# -# \Exception (and its subclasses including \RuntimeError): -# require 'json/add/exception' -# ruby0 = Exception.new('A message') # A message -# json = JSON.generate(ruby0) # {"json_class":"Exception","m":"A message","b":null} -# ruby1 = JSON.parse(json, create_additions: true) # A message -# ruby1.class # Exception -# ruby0 = RuntimeError.new('Another message') # Another message -# json = JSON.generate(ruby0) # {"json_class":"RuntimeError","m":"Another message","b":null} -# ruby1 = JSON.parse(json, create_additions: true) # Another message -# ruby1.class # RuntimeError -# -# \OpenStruct: -# require 'json/add/ostruct' -# ruby0 = OpenStruct.new(name: 'Matz', language: 'Ruby') # # -# json = JSON.generate(ruby0) # {"json_class":"OpenStruct","t":{"name":"Matz","language":"Ruby"}} -# ruby1 = JSON.parse(json, create_additions: true) # # -# ruby1.class # OpenStruct -# -# \Range: -# require 'json/add/range' -# ruby0 = Range.new(0, 2) # 0..2 -# json = JSON.generate(ruby0) # {"json_class":"Range","a":[0,2,false]} -# ruby1 = JSON.parse(json, create_additions: true) # 0..2 -# ruby1.class # Range -# -# \Rational: -# require 'json/add/rational' -# ruby0 = Rational(1, 3) # 1/3 -# json = JSON.generate(ruby0) # {"json_class":"Rational","n":1,"d":3} -# ruby1 = JSON.parse(json, create_additions: true) # 1/3 -# ruby1.class # Rational -# -# \Regexp: -# require 'json/add/regexp' -# ruby0 = Regexp.new('foo') # (?-mix:foo) -# json = JSON.generate(ruby0) # {"json_class":"Regexp","o":0,"s":"foo"} -# ruby1 = JSON.parse(json, create_additions: true) # (?-mix:foo) -# ruby1.class # Regexp -# -# \Set: -# require 'json/add/set' -# ruby0 = Set.new([0, 1, 2]) # # -# json = JSON.generate(ruby0) # {"json_class":"Set","a":[0,1,2]} -# ruby1 = JSON.parse(json, create_additions: true) # # -# ruby1.class # Set -# -# \Struct: -# require 'json/add/struct' -# Customer = Struct.new(:name, :address) # Customer -# ruby0 = Customer.new("Dave", "123 Main") # # -# json = JSON.generate(ruby0) # {"json_class":"Customer","v":["Dave","123 Main"]} -# ruby1 = JSON.parse(json, create_additions: true) # # -# ruby1.class # Customer -# -# \Symbol: -# require 'json/add/symbol' -# ruby0 = :foo # foo -# json = JSON.generate(ruby0) # {"json_class":"Symbol","s":"foo"} -# ruby1 = JSON.parse(json, create_additions: true) # foo -# ruby1.class # Symbol -# -# \Time: -# require 'json/add/time' -# ruby0 = Time.now # 2020-05-02 11:28:26 -0500 -# json = JSON.generate(ruby0) # {"json_class":"Time","s":1588436906,"n":840560000} -# ruby1 = JSON.parse(json, create_additions: true) # 2020-05-02 11:28:26 -0500 -# ruby1.class # Time -# -# -# === Custom \JSON Additions -# -# In addition to the \JSON additions provided, -# you can craft \JSON additions of your own, -# either for Ruby built-in classes or for user-defined classes. -# -# Here's a user-defined class +Foo+: -# class Foo -# attr_accessor :bar, :baz -# def initialize(bar, baz) -# self.bar = bar -# self.baz = baz -# end -# end -# -# Here's the \JSON addition for it: -# # Extend class Foo with JSON addition. -# class Foo -# # Serialize Foo object with its class name and arguments -# def to_json(*args) -# { -# JSON.create_id => self.class.name, -# 'a' => [ bar, baz ] -# }.to_json(*args) -# end -# # Deserialize JSON string by constructing new Foo object with arguments. -# def self.json_create(object) -# new(*object['a']) -# end -# end -# -# Demonstration: -# require 'json' -# # This Foo object has no custom addition. -# foo0 = Foo.new(0, 1) -# json0 = JSON.generate(foo0) -# obj0 = JSON.parse(json0) -# # Lood the custom addition. -# require_relative 'foo_addition' -# # This foo has the custom addition. -# foo1 = Foo.new(0, 1) -# json1 = JSON.generate(foo1) -# obj1 = JSON.parse(json1, create_additions: true) -# # Make a nice display. -# display = <<~EOT -# Generated JSON: -# Without custom addition: #{json0} (#{json0.class}) -# With custom addition: #{json1} (#{json1.class}) -# Parsed JSON: -# Without custom addition: #{obj0.inspect} (#{obj0.class}) -# With custom addition: #{obj1.inspect} (#{obj1.class}) -# EOT -# puts display -# -# Output: -# -# Generated JSON: -# Without custom addition: "#" (String) -# With custom addition: {"json_class":"Foo","a":[0,1]} (String) -# Parsed JSON: -# Without custom addition: "#" (String) -# With custom addition: # (Foo) -# -# pkg:gem/json#lib/json/version.rb:3 -module JSON - private - - # :call-seq: - # JSON.dump(obj, io = nil, limit = nil) - # - # Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result. - # - # The default options can be changed via method JSON.dump_default_options. - # - # - Argument +io+, if given, should respond to method +write+; - # the \JSON \String is written to +io+, and +io+ is returned. - # If +io+ is not given, the \JSON \String is returned. - # - Argument +limit+, if given, is passed to JSON.generate as option +max_nesting+. - # - # --- - # - # When argument +io+ is not given, returns the \JSON \String generated from +obj+: - # obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} - # json = JSON.dump(obj) - # json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}" - # - # When argument +io+ is given, writes the \JSON \String to +io+ and returns +io+: - # path = 't.json' - # File.open(path, 'w') do |file| - # JSON.dump(obj, file) - # end # => # - # puts File.read(path) - # Output: - # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} - # - # pkg:gem/json#lib/json/common.rb:941 - def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end - - # :call-seq: - # JSON.fast_generate(obj, opts) -> new_string - # - # Arguments +obj+ and +opts+ here are the same as - # arguments +obj+ and +opts+ in JSON.generate. - # - # By default, generates \JSON data without checking - # for circular references in +obj+ (option +max_nesting+ set to +false+, disabled). - # - # Raises an exception if +obj+ contains circular references: - # a = []; b = []; a.push(b); b.push(a) - # # Raises SystemStackError (stack level too deep): - # JSON.fast_generate(a) - # - # pkg:gem/json#lib/json/common.rb:471 - def fast_generate(obj, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:986 - def fast_unparse(*_arg0, **_arg1, &_arg2); end - - # :call-seq: - # JSON.generate(obj, opts = nil) -> new_string - # - # Returns a \String containing the generated \JSON data. - # - # See also JSON.pretty_generate. - # - # Argument +obj+ is the Ruby object to be converted to \JSON. - # - # Argument +opts+, if given, contains a \Hash of options for the generation. - # See {Generating Options}[#module-JSON-label-Generating+Options]. - # - # --- - # - # When +obj+ is an \Array, returns a \String containing a \JSON array: - # obj = ["foo", 1.0, true, false, nil] - # json = JSON.generate(obj) - # json # => '["foo",1.0,true,false,null]' - # - # When +obj+ is a \Hash, returns a \String containing a \JSON object: - # obj = {foo: 0, bar: 's', baz: :bat} - # json = JSON.generate(obj) - # json # => '{"foo":0,"bar":"s","baz":"bat"}' - # - # For examples of generating from other Ruby objects, see - # {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects]. - # - # --- - # - # Raises an exception if any formatting option is not a \String. - # - # Raises an exception if +obj+ contains circular references: - # a = []; b = []; a.push(b); b.push(a) - # # Raises JSON::NestingError (nesting of 100 is too deep): - # JSON.generate(a) - # - # pkg:gem/json#lib/json/common.rb:450 - def generate(obj, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.load(source, options = {}) -> object - # JSON.load(source, proc = nil, options = {}) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # BEWARE: This method is meant to serialise data from trusted user input, - # like from your own database server or clients under your control, it could - # be dangerous to allow untrusted users to pass JSON sources into it. - # If you must use it, use JSON.unsafe_load instead to make it clear. - # - # Since JSON version 2.8.0, `load` emits a deprecation warning when a - # non native type is deserialized, without `create_additions` being explicitly - # enabled, and in JSON version 3.0, `load` will have `create_additions` disabled - # by default. - # - # - Argument +source+ must be, or be convertible to, a \String: - # - If +source+ responds to instance method +to_str+, - # source.to_str becomes the source. - # - If +source+ responds to instance method +to_io+, - # source.to_io.read becomes the source. - # - If +source+ responds to instance method +read+, - # source.read becomes the source. - # - If both of the following are true, source becomes the \String 'null': - # - Option +allow_blank+ specifies a truthy value. - # - The source, as defined above, is +nil+ or the empty \String ''. - # - Otherwise, +source+ remains the source. - # - Argument +proc+, if given, must be a \Proc that accepts one argument. - # It will be called recursively with each result (depth-first order). - # See details below. - # - Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # The default options can be changed via method JSON.load_default_options=. - # - # --- - # - # When no +proc+ is given, modifies +source+ as above and returns the result of - # parse(source, opts); see #parse. - # - # Source for following examples: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # - # Load a \String: - # ruby = JSON.load(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load an \IO object: - # require 'stringio' - # object = JSON.load(StringIO.new(source)) - # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load a \File object: - # path = 't.json' - # File.write(path, source) - # File.open(path) do |file| - # JSON.load(file) - # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # When +proc+ is given: - # - Modifies +source+ as above. - # - Gets the +result+ from calling parse(source, opts). - # - Recursively calls proc(result). - # - Returns the final result. - # - # Example: - # require 'json' - # - # # Some classes for the example. - # class Base - # def initialize(attributes) - # @attributes = attributes - # end - # end - # class User < Base; end - # class Account < Base; end - # class Admin < Base; end - # # The JSON source. - # json = <<-EOF - # { - # "users": [ - # {"type": "User", "username": "jane", "email": "jane@example.com"}, - # {"type": "User", "username": "john", "email": "john@example.com"} - # ], - # "accounts": [ - # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, - # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} - # ], - # "admins": {"type": "Admin", "password": "0wn3d"} - # } - # EOF - # # Deserializer method. - # def deserialize_obj(obj, safe_types = %w(User Account Admin)) - # type = obj.is_a?(Hash) && obj["type"] - # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj - # end - # # Call to JSON.load - # ruby = JSON.load(json, proc {|obj| - # case obj - # when Hash - # obj.each {|k, v| obj[k] = deserialize_obj v } - # when Array - # obj.map! {|v| deserialize_obj v } - # end - # obj - # }) - # pp ruby - # Output: - # {"users"=> - # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, - # #"User", "username"=>"john", "email"=>"john@example.com"}>], - # "accounts"=> - # [{"account"=> - # #"Account", "paid"=>true, "account_id"=>"1234"}>}, - # {"account"=> - # #"Account", "paid"=>false, "account_id"=>"1235"}>}], - # "admins"=> - # #"Admin", "password"=>"0wn3d"}>} - # - # pkg:gem/json#lib/json/common.rb:865 - def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end - - # :call-seq: - # JSON.load_file(path, opts={}) -> object - # - # Calls: - # parse(File.read(path), opts) - # - # See method #parse. - # - # pkg:gem/json#lib/json/common.rb:399 - def load_file(filespec, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.load_file!(path, opts = {}) - # - # Calls: - # JSON.parse!(File.read(path, opts)) - # - # See method #parse! - # - # pkg:gem/json#lib/json/common.rb:410 - def load_file!(filespec, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.parse(source, opts) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # Argument +source+ contains the \String to be parsed. - # - # Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # - # --- - # - # When +source+ is a \JSON array, returns a Ruby \Array: - # source = '["foo", 1.0, true, false, null]' - # ruby = JSON.parse(source) - # ruby # => ["foo", 1.0, true, false, nil] - # ruby.class # => Array - # - # When +source+ is a \JSON object, returns a Ruby \Hash: - # source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' - # ruby = JSON.parse(source) - # ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} - # ruby.class # => Hash - # - # For examples of parsing for all \JSON data types, see - # {Parsing \JSON}[#module-JSON-label-Parsing+JSON]. - # - # Parses nested JSON objects: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # ruby = JSON.parse(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # Raises an exception if +source+ is not valid JSON: - # # Raises JSON::ParserError (783: unexpected token at ''): - # JSON.parse('') - # - # pkg:gem/json#lib/json/common.rb:362 - def parse(source, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.parse!(source, opts) -> object - # - # Calls - # parse(source, opts) - # with +source+ and possibly modified +opts+. - # - # Differences from JSON.parse: - # - Option +max_nesting+, if not provided, defaults to +false+, - # which disables checking for nesting depth. - # - Option +allow_nan+, if not provided, defaults to +true+. - # - # pkg:gem/json#lib/json/common.rb:384 - def parse!(source, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.pretty_generate(obj, opts = nil) -> new_string - # - # Arguments +obj+ and +opts+ here are the same as - # arguments +obj+ and +opts+ in JSON.generate. - # - # Default options are: - # { - # indent: ' ', # Two spaces - # space: ' ', # One space - # array_nl: "\n", # Newline - # object_nl: "\n" # Newline - # } - # - # Example: - # obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} - # json = JSON.pretty_generate(obj) - # puts json - # Output: - # { - # "foo": [ - # "bar", - # "baz" - # ], - # "bat": { - # "bam": 0, - # "bad": 1 - # } - # } - # - # pkg:gem/json#lib/json/common.rb:518 - def pretty_generate(obj, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:996 - def pretty_unparse(*_arg0, **_arg1, &_arg2); end - - # pkg:gem/json#lib/json/common.rb:1006 - def restore(*_arg0, **_arg1, &_arg2); end - - # :stopdoc: - # All these were meant to be deprecated circa 2009, but were just set as undocumented - # so usage still exist in the wild. - # - # pkg:gem/json#lib/json/common.rb:976 - def unparse(*_arg0, **_arg1, &_arg2); end - - # :call-seq: - # JSON.unsafe_load(source, options = {}) -> object - # JSON.unsafe_load(source, proc = nil, options = {}) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # BEWARE: This method is meant to serialise data from trusted user input, - # like from your own database server or clients under your control, it could - # be dangerous to allow untrusted users to pass JSON sources into it. - # - # - Argument +source+ must be, or be convertible to, a \String: - # - If +source+ responds to instance method +to_str+, - # source.to_str becomes the source. - # - If +source+ responds to instance method +to_io+, - # source.to_io.read becomes the source. - # - If +source+ responds to instance method +read+, - # source.read becomes the source. - # - If both of the following are true, source becomes the \String 'null': - # - Option +allow_blank+ specifies a truthy value. - # - The source, as defined above, is +nil+ or the empty \String ''. - # - Otherwise, +source+ remains the source. - # - Argument +proc+, if given, must be a \Proc that accepts one argument. - # It will be called recursively with each result (depth-first order). - # See details below. - # - Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # The default options can be changed via method JSON.unsafe_load_default_options=. - # - # --- - # - # When no +proc+ is given, modifies +source+ as above and returns the result of - # parse(source, opts); see #parse. - # - # Source for following examples: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # - # Load a \String: - # ruby = JSON.unsafe_load(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load an \IO object: - # require 'stringio' - # object = JSON.unsafe_load(StringIO.new(source)) - # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load a \File object: - # path = 't.json' - # File.write(path, source) - # File.open(path) do |file| - # JSON.unsafe_load(file) - # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # When +proc+ is given: - # - Modifies +source+ as above. - # - Gets the +result+ from calling parse(source, opts). - # - Recursively calls proc(result). - # - Returns the final result. - # - # Example: - # require 'json' - # - # # Some classes for the example. - # class Base - # def initialize(attributes) - # @attributes = attributes - # end - # end - # class User < Base; end - # class Account < Base; end - # class Admin < Base; end - # # The JSON source. - # json = <<-EOF - # { - # "users": [ - # {"type": "User", "username": "jane", "email": "jane@example.com"}, - # {"type": "User", "username": "john", "email": "john@example.com"} - # ], - # "accounts": [ - # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, - # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} - # ], - # "admins": {"type": "Admin", "password": "0wn3d"} - # } - # EOF - # # Deserializer method. - # def deserialize_obj(obj, safe_types = %w(User Account Admin)) - # type = obj.is_a?(Hash) && obj["type"] - # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj - # end - # # Call to JSON.unsafe_load - # ruby = JSON.unsafe_load(json, proc {|obj| - # case obj - # when Hash - # obj.each {|k, v| obj[k] = deserialize_obj v } - # when Array - # obj.map! {|v| deserialize_obj v } - # end - # obj - # }) - # pp ruby - # Output: - # {"users"=> - # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, - # #"User", "username"=>"john", "email"=>"john@example.com"}>], - # "accounts"=> - # [{"account"=> - # #"Account", "paid"=>true, "account_id"=>"1234"}>}, - # {"account"=> - # #"Account", "paid"=>false, "account_id"=>"1235"}>}], - # "admins"=> - # #"Admin", "password"=>"0wn3d"}>} - # - # pkg:gem/json#lib/json/common.rb:694 - def unsafe_load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end - - class << self - # :call-seq: - # JSON[object] -> new_array or new_string - # - # If +object+ is a \String, - # calls JSON.parse with +object+ and +opts+ (see method #parse): - # json = '[0, 1, null]' - # JSON[json]# => [0, 1, nil] - # - # Otherwise, calls JSON.generate with +object+ and +opts+ (see method #generate): - # ruby = [0, 1, nil] - # JSON[ruby] # => '[0,1,null]' - # - # pkg:gem/json#lib/json/common.rb:132 - def [](object, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:217 - def _dump_default_options; end - - # pkg:gem/json#lib/json/common.rb:217 - def _load_default_options; end - - # pkg:gem/json#lib/json/common.rb:217 - def _unsafe_load_default_options; end - - # Returns the current create identifier. - # See also JSON.create_id=. - # - # pkg:gem/json#lib/json/common.rb:245 - def create_id; end - - # Sets create identifier, which is used to decide if the _json_create_ - # hook of a class should be called; initial value is +json_class+: - # JSON.create_id # => 'json_class' - # - # pkg:gem/json#lib/json/common.rb:239 - def create_id=(new_value); end - - # pkg:gem/json#lib/json/common.rb:104 - def deprecation_warning(message, uplevel = T.unsafe(nil)); end - - # :call-seq: - # JSON.dump(obj, io = nil, limit = nil) - # - # Dumps +obj+ as a \JSON string, i.e. calls generate on the object and returns the result. - # - # The default options can be changed via method JSON.dump_default_options. - # - # - Argument +io+, if given, should respond to method +write+; - # the \JSON \String is written to +io+, and +io+ is returned. - # If +io+ is not given, the \JSON \String is returned. - # - Argument +limit+, if given, is passed to JSON.generate as option +max_nesting+. - # - # --- - # - # When argument +io+ is not given, returns the \JSON \String generated from +obj+: - # obj = {foo: [0, 1], bar: {baz: 2, bat: 3}, bam: :bad} - # json = JSON.dump(obj) - # json # => "{\"foo\":[0,1],\"bar\":{\"baz\":2,\"bat\":3},\"bam\":\"bad\"}" - # - # When argument +io+ is given, writes the \JSON \String to +io+ and returns +io+: - # path = 't.json' - # File.open(path, 'w') do |file| - # JSON.dump(obj, file) - # end # => # - # puts File.read(path) - # Output: - # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} - # - # pkg:gem/json#lib/json/common.rb:941 - def dump(obj, anIO = T.unsafe(nil), limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:217 - def dump_default_options; end - - # pkg:gem/json#lib/json/common.rb:217 - def dump_default_options=(val); end - - # :call-seq: - # JSON.fast_generate(obj, opts) -> new_string - # - # Arguments +obj+ and +opts+ here are the same as - # arguments +obj+ and +opts+ in JSON.generate. - # - # By default, generates \JSON data without checking - # for circular references in +obj+ (option +max_nesting+ set to +false+, disabled). - # - # Raises an exception if +obj+ contains circular references: - # a = []; b = []; a.push(b); b.push(a) - # # Raises SystemStackError (stack level too deep): - # JSON.fast_generate(a) - # - # pkg:gem/json#lib/json/common.rb:471 - def fast_generate(obj, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:986 - def fast_unparse(*_arg0, **_arg1, &_arg2); end - - # :call-seq: - # JSON.generate(obj, opts = nil) -> new_string - # - # Returns a \String containing the generated \JSON data. - # - # See also JSON.pretty_generate. - # - # Argument +obj+ is the Ruby object to be converted to \JSON. - # - # Argument +opts+, if given, contains a \Hash of options for the generation. - # See {Generating Options}[#module-JSON-label-Generating+Options]. - # - # --- - # - # When +obj+ is an \Array, returns a \String containing a \JSON array: - # obj = ["foo", 1.0, true, false, nil] - # json = JSON.generate(obj) - # json # => '["foo",1.0,true,false,null]' - # - # When +obj+ is a \Hash, returns a \String containing a \JSON object: - # obj = {foo: 0, bar: 's', baz: :bat} - # json = JSON.generate(obj) - # json # => '{"foo":0,"bar":"s","baz":"bat"}' - # - # For examples of generating from other Ruby objects, see - # {Generating \JSON from Other Objects}[#module-JSON-label-Generating+JSON+from+Other+Objects]. - # - # --- - # - # Raises an exception if any formatting option is not a \String. - # - # Raises an exception if +obj+ contains circular references: - # a = []; b = []; a.push(b); b.push(a) - # # Raises JSON::NestingError (nesting of 100 is too deep): - # JSON.generate(a) - # - # pkg:gem/json#lib/json/common.rb:450 - def generate(obj, opts = T.unsafe(nil)); end - - # Returns the JSON generator module that is used by JSON. - # - # pkg:gem/json#lib/json/common.rb:188 - def generator; end - - # Set the module _generator_ to be used by JSON. - # - # pkg:gem/json#lib/json/common.rb:156 - def generator=(generator); end - - # :call-seq: - # JSON.load(source, options = {}) -> object - # JSON.load(source, proc = nil, options = {}) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # BEWARE: This method is meant to serialise data from trusted user input, - # like from your own database server or clients under your control, it could - # be dangerous to allow untrusted users to pass JSON sources into it. - # If you must use it, use JSON.unsafe_load instead to make it clear. - # - # Since JSON version 2.8.0, `load` emits a deprecation warning when a - # non native type is deserialized, without `create_additions` being explicitly - # enabled, and in JSON version 3.0, `load` will have `create_additions` disabled - # by default. - # - # - Argument +source+ must be, or be convertible to, a \String: - # - If +source+ responds to instance method +to_str+, - # source.to_str becomes the source. - # - If +source+ responds to instance method +to_io+, - # source.to_io.read becomes the source. - # - If +source+ responds to instance method +read+, - # source.read becomes the source. - # - If both of the following are true, source becomes the \String 'null': - # - Option +allow_blank+ specifies a truthy value. - # - The source, as defined above, is +nil+ or the empty \String ''. - # - Otherwise, +source+ remains the source. - # - Argument +proc+, if given, must be a \Proc that accepts one argument. - # It will be called recursively with each result (depth-first order). - # See details below. - # - Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # The default options can be changed via method JSON.load_default_options=. - # - # --- - # - # When no +proc+ is given, modifies +source+ as above and returns the result of - # parse(source, opts); see #parse. - # - # Source for following examples: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # - # Load a \String: - # ruby = JSON.load(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load an \IO object: - # require 'stringio' - # object = JSON.load(StringIO.new(source)) - # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load a \File object: - # path = 't.json' - # File.write(path, source) - # File.open(path) do |file| - # JSON.load(file) - # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # When +proc+ is given: - # - Modifies +source+ as above. - # - Gets the +result+ from calling parse(source, opts). - # - Recursively calls proc(result). - # - Returns the final result. - # - # Example: - # require 'json' - # - # # Some classes for the example. - # class Base - # def initialize(attributes) - # @attributes = attributes - # end - # end - # class User < Base; end - # class Account < Base; end - # class Admin < Base; end - # # The JSON source. - # json = <<-EOF - # { - # "users": [ - # {"type": "User", "username": "jane", "email": "jane@example.com"}, - # {"type": "User", "username": "john", "email": "john@example.com"} - # ], - # "accounts": [ - # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, - # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} - # ], - # "admins": {"type": "Admin", "password": "0wn3d"} - # } - # EOF - # # Deserializer method. - # def deserialize_obj(obj, safe_types = %w(User Account Admin)) - # type = obj.is_a?(Hash) && obj["type"] - # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj - # end - # # Call to JSON.load - # ruby = JSON.load(json, proc {|obj| - # case obj - # when Hash - # obj.each {|k, v| obj[k] = deserialize_obj v } - # when Array - # obj.map! {|v| deserialize_obj v } - # end - # obj - # }) - # pp ruby - # Output: - # {"users"=> - # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, - # #"User", "username"=>"john", "email"=>"john@example.com"}>], - # "accounts"=> - # [{"account"=> - # #"Account", "paid"=>true, "account_id"=>"1234"}>}, - # {"account"=> - # #"Account", "paid"=>false, "account_id"=>"1235"}>}], - # "admins"=> - # #"Admin", "password"=>"0wn3d"}>} - # - # pkg:gem/json#lib/json/common.rb:865 - def load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:217 - def load_default_options; end - - # pkg:gem/json#lib/json/common.rb:217 - def load_default_options=(val); end - - # :call-seq: - # JSON.load_file(path, opts={}) -> object - # - # Calls: - # parse(File.read(path), opts) - # - # See method #parse. - # - # pkg:gem/json#lib/json/common.rb:399 - def load_file(filespec, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.load_file!(path, opts = {}) - # - # Calls: - # JSON.parse!(File.read(path, opts)) - # - # See method #parse! - # - # pkg:gem/json#lib/json/common.rb:410 - def load_file!(filespec, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.parse(source, opts) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # Argument +source+ contains the \String to be parsed. - # - # Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # - # --- - # - # When +source+ is a \JSON array, returns a Ruby \Array: - # source = '["foo", 1.0, true, false, null]' - # ruby = JSON.parse(source) - # ruby # => ["foo", 1.0, true, false, nil] - # ruby.class # => Array - # - # When +source+ is a \JSON object, returns a Ruby \Hash: - # source = '{"a": "foo", "b": 1.0, "c": true, "d": false, "e": null}' - # ruby = JSON.parse(source) - # ruby # => {"a"=>"foo", "b"=>1.0, "c"=>true, "d"=>false, "e"=>nil} - # ruby.class # => Hash - # - # For examples of parsing for all \JSON data types, see - # {Parsing \JSON}[#module-JSON-label-Parsing+JSON]. - # - # Parses nested JSON objects: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # ruby = JSON.parse(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # Raises an exception if +source+ is not valid JSON: - # # Raises JSON::ParserError (783: unexpected token at ''): - # JSON.parse('') - # - # pkg:gem/json#lib/json/common.rb:362 - def parse(source, opts = T.unsafe(nil)); end - - # :call-seq: - # JSON.parse!(source, opts) -> object - # - # Calls - # parse(source, opts) - # with +source+ and possibly modified +opts+. - # - # Differences from JSON.parse: - # - Option +max_nesting+, if not provided, defaults to +false+, - # which disables checking for nesting depth. - # - Option +allow_nan+, if not provided, defaults to +true+. - # - # pkg:gem/json#lib/json/common.rb:384 - def parse!(source, opts = T.unsafe(nil)); end - - # Returns the JSON parser class that is used by JSON. - # - # pkg:gem/json#lib/json/common.rb:146 - def parser; end - - # Set the JSON parser class _parser_ to be used by JSON. - # - # pkg:gem/json#lib/json/common.rb:149 - def parser=(parser); end - - # :call-seq: - # JSON.pretty_generate(obj, opts = nil) -> new_string - # - # Arguments +obj+ and +opts+ here are the same as - # arguments +obj+ and +opts+ in JSON.generate. - # - # Default options are: - # { - # indent: ' ', # Two spaces - # space: ' ', # One space - # array_nl: "\n", # Newline - # object_nl: "\n" # Newline - # } - # - # Example: - # obj = {foo: [:bar, :baz], bat: {bam: 0, bad: 1}} - # json = JSON.pretty_generate(obj) - # puts json - # Output: - # { - # "foo": [ - # "bar", - # "baz" - # ], - # "bat": { - # "bam": 0, - # "bad": 1 - # } - # } - # - # pkg:gem/json#lib/json/common.rb:518 - def pretty_generate(obj, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:996 - def pretty_unparse(*_arg0, **_arg1, &_arg2); end - - # pkg:gem/json#lib/json/common.rb:1006 - def restore(*_arg0, **_arg1, &_arg2); end - - # Sets or Returns the JSON generator state class that is used by JSON. - # - # pkg:gem/json#lib/json/common.rb:191 - def state; end - - # Sets or Returns the JSON generator state class that is used by JSON. - # - # pkg:gem/json#lib/json/common.rb:191 - def state=(_arg0); end - - # :stopdoc: - # All these were meant to be deprecated circa 2009, but were just set as undocumented - # so usage still exist in the wild. - # - # pkg:gem/json#lib/json/common.rb:976 - def unparse(*_arg0, **_arg1, &_arg2); end - - # :call-seq: - # JSON.unsafe_load(source, options = {}) -> object - # JSON.unsafe_load(source, proc = nil, options = {}) -> object - # - # Returns the Ruby objects created by parsing the given +source+. - # - # BEWARE: This method is meant to serialise data from trusted user input, - # like from your own database server or clients under your control, it could - # be dangerous to allow untrusted users to pass JSON sources into it. - # - # - Argument +source+ must be, or be convertible to, a \String: - # - If +source+ responds to instance method +to_str+, - # source.to_str becomes the source. - # - If +source+ responds to instance method +to_io+, - # source.to_io.read becomes the source. - # - If +source+ responds to instance method +read+, - # source.read becomes the source. - # - If both of the following are true, source becomes the \String 'null': - # - Option +allow_blank+ specifies a truthy value. - # - The source, as defined above, is +nil+ or the empty \String ''. - # - Otherwise, +source+ remains the source. - # - Argument +proc+, if given, must be a \Proc that accepts one argument. - # It will be called recursively with each result (depth-first order). - # See details below. - # - Argument +opts+, if given, contains a \Hash of options for the parsing. - # See {Parsing Options}[#module-JSON-label-Parsing+Options]. - # The default options can be changed via method JSON.unsafe_load_default_options=. - # - # --- - # - # When no +proc+ is given, modifies +source+ as above and returns the result of - # parse(source, opts); see #parse. - # - # Source for following examples: - # source = <<~JSON - # { - # "name": "Dave", - # "age" :40, - # "hats": [ - # "Cattleman's", - # "Panama", - # "Tophat" - # ] - # } - # JSON - # - # Load a \String: - # ruby = JSON.unsafe_load(source) - # ruby # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load an \IO object: - # require 'stringio' - # object = JSON.unsafe_load(StringIO.new(source)) - # object # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # Load a \File object: - # path = 't.json' - # File.write(path, source) - # File.open(path) do |file| - # JSON.unsafe_load(file) - # end # => {"name"=>"Dave", "age"=>40, "hats"=>["Cattleman's", "Panama", "Tophat"]} - # - # --- - # - # When +proc+ is given: - # - Modifies +source+ as above. - # - Gets the +result+ from calling parse(source, opts). - # - Recursively calls proc(result). - # - Returns the final result. - # - # Example: - # require 'json' - # - # # Some classes for the example. - # class Base - # def initialize(attributes) - # @attributes = attributes - # end - # end - # class User < Base; end - # class Account < Base; end - # class Admin < Base; end - # # The JSON source. - # json = <<-EOF - # { - # "users": [ - # {"type": "User", "username": "jane", "email": "jane@example.com"}, - # {"type": "User", "username": "john", "email": "john@example.com"} - # ], - # "accounts": [ - # {"account": {"type": "Account", "paid": true, "account_id": "1234"}}, - # {"account": {"type": "Account", "paid": false, "account_id": "1235"}} - # ], - # "admins": {"type": "Admin", "password": "0wn3d"} - # } - # EOF - # # Deserializer method. - # def deserialize_obj(obj, safe_types = %w(User Account Admin)) - # type = obj.is_a?(Hash) && obj["type"] - # safe_types.include?(type) ? Object.const_get(type).new(obj) : obj - # end - # # Call to JSON.unsafe_load - # ruby = JSON.unsafe_load(json, proc {|obj| - # case obj - # when Hash - # obj.each {|k, v| obj[k] = deserialize_obj v } - # when Array - # obj.map! {|v| deserialize_obj v } - # end - # obj - # }) - # pp ruby - # Output: - # {"users"=> - # [#"User", "username"=>"jane", "email"=>"jane@example.com"}>, - # #"User", "username"=>"john", "email"=>"john@example.com"}>], - # "accounts"=> - # [{"account"=> - # #"Account", "paid"=>true, "account_id"=>"1234"}>}, - # {"account"=> - # #"Account", "paid"=>false, "account_id"=>"1235"}>}], - # "admins"=> - # #"Admin", "password"=>"0wn3d"}>} - # - # pkg:gem/json#lib/json/common.rb:694 - def unsafe_load(source, proc = T.unsafe(nil), options = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:217 - def unsafe_load_default_options; end - - # pkg:gem/json#lib/json/common.rb:217 - def unsafe_load_default_options=(val); end - - private - - # pkg:gem/json#lib/json/common.rb:1019 - def const_missing(const_name); end - - # pkg:gem/json#lib/json/common.rb:214 - def deprecated_singleton_attr_accessor(*attrs); end - - # Called from the extension when a hash has both string and symbol keys - # - # pkg:gem/json#lib/json/common.rb:196 - def on_mixed_keys_hash(hash, do_raise); end - end -end - -# JSON::Coder holds a parser and generator configuration. -# -# module MyApp -# JSONC_CODER = JSON::Coder.new( -# allow_trailing_comma: true -# ) -# end -# -# MyApp::JSONC_CODER.load(document) -# -# pkg:gem/json#lib/json/common.rb:1045 -class JSON::Coder - # :call-seq: - # JSON.new(options = nil, &block) - # - # Argument +options+, if given, contains a \Hash of options for both parsing and generating. - # See {Parsing Options}[rdoc-ref:JSON@Parsing+Options], - # and {Generating Options}[rdoc-ref:JSON@Generating+Options]. - # - # For generation, the strict: true option is always set. When a Ruby object with no native \JSON counterpart is - # encountered, the block provided to the initialize method is invoked, and must return a Ruby object that has a native - # \JSON counterpart: - # - # module MyApp - # API_JSON_CODER = JSON::Coder.new do |object| - # case object - # when Time - # object.iso8601(3) - # else - # object # Unknown type, will raise - # end - # end - # end - # - # puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z" - # - # pkg:gem/json#lib/json/common.rb:1070 - def initialize(options = T.unsafe(nil), &as_json); end - - # call-seq: - # dump(object) -> String - # dump(object, io) -> io - # - # Serialize the given object into a \JSON document. - # - # pkg:gem/json#lib/json/common.rb:1088 - def dump(object, io = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:1091 - def generate(object, io = T.unsafe(nil)); end - - # call-seq: - # load(string) -> Object - # - # Parse the given \JSON document and return an equivalent Ruby object. - # - # pkg:gem/json#lib/json/common.rb:1097 - def load(source); end - - # call-seq: - # load(path) -> Object - # - # Parse the given \JSON document and return an equivalent Ruby object. - # - # pkg:gem/json#lib/json/common.rb:1106 - def load_file(path); end - - # pkg:gem/json#lib/json/common.rb:1100 - def parse(source); end -end - -# pkg:gem/json#lib/json/ext.rb:39 -class JSON::Ext::Generator::State - # call-seq: new(opts = {}) - # - # Instantiates a new State object, configured by _opts_. - # - # Argument +opts+, if given, contains a \Hash of options for the generation. - # See {Generating Options}[rdoc-ref:JSON@Generating+Options]. - # - # pkg:gem/json#lib/json/ext.rb:39 - def initialize(opts = T.unsafe(nil)); end - - # call-seq: [](name) - # - # Returns the value returned by method +name+. - # - # pkg:gem/json#lib/json/ext/generator/state.rb:78 - def [](name); end - - # call-seq: []=(name, value) - # - # Sets the attribute name to value. - # - # pkg:gem/json#lib/json/ext/generator/state.rb:92 - def []=(name, value); end - - # pkg:gem/json#lib/json/ext.rb:39 - def _generate_no_fallback(*_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def allow_nan=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def allow_nan?; end - - # pkg:gem/json#lib/json/ext.rb:39 - def array_nl; end - - # pkg:gem/json#lib/json/ext.rb:39 - def array_nl=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def as_json; end - - # pkg:gem/json#lib/json/ext.rb:39 - def as_json=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def ascii_only=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def ascii_only?; end - - # pkg:gem/json#lib/json/ext.rb:39 - def buffer_initial_length; end - - # pkg:gem/json#lib/json/ext.rb:39 - def buffer_initial_length=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def check_circular?; end - - # call-seq: configure(opts) - # - # Configure this State instance with the Hash _opts_, and return - # itself. - # - # pkg:gem/json#lib/json/ext/generator/state.rb:23 - def configure(opts); end - - # pkg:gem/json#lib/json/ext.rb:39 - def depth; end - - # pkg:gem/json#lib/json/ext.rb:39 - def depth=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def escape_slash; end - - # pkg:gem/json#lib/json/ext.rb:39 - def escape_slash=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def escape_slash?; end - - # pkg:gem/json#lib/json/ext.rb:39 - def generate(*_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def indent; end - - # pkg:gem/json#lib/json/ext.rb:39 - def indent=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def max_nesting; end - - # pkg:gem/json#lib/json/ext.rb:39 - def max_nesting=(_arg0); end - - # pkg:gem/json#lib/json/ext/generator/state.rb:36 - def merge(opts); end - - # pkg:gem/json#lib/json/ext.rb:39 - def object_nl; end - - # pkg:gem/json#lib/json/ext.rb:39 - def object_nl=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def script_safe; end - - # pkg:gem/json#lib/json/ext.rb:39 - def script_safe=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def script_safe?; end - - # pkg:gem/json#lib/json/ext.rb:39 - def sort_keys; end - - # pkg:gem/json#lib/json/ext.rb:39 - def sort_keys=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def space; end - - # pkg:gem/json#lib/json/ext.rb:39 - def space=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def space_before; end - - # pkg:gem/json#lib/json/ext.rb:39 - def space_before=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def strict; end - - # pkg:gem/json#lib/json/ext.rb:39 - def strict=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def strict?; end - - # call-seq: to_h - # - # Returns the configuration instance variables as a hash, that can be - # passed to the configure method. - # - # pkg:gem/json#lib/json/ext/generator/state.rb:42 - def to_h; end - - # pkg:gem/json#lib/json/ext/generator/state.rb:73 - def to_hash; end - - private - - # pkg:gem/json#lib/json/ext.rb:39 - def _configure(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def allow_duplicate_key?; end - - # pkg:gem/json#lib/json/ext.rb:39 - def initialize_copy(_arg0); end - - class << self - # pkg:gem/json#lib/json/ext.rb:39 - def _generate_no_fallback(_arg0, _arg1, _arg2); end - - # pkg:gem/json#lib/json/ext.rb:39 - def default_sort_keys_proc=(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def from_state(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:39 - def generate(_arg0, _arg1, _arg2); end - end -end - -# pkg:gem/json#lib/json/ext.rb:9 -class JSON::Ext::Parser - # pkg:gem/json#lib/json/ext.rb:17 - def initialize(source, opts = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/ext.rb:26 - def parse; end - - # pkg:gem/json#lib/json/ext.rb:22 - def source; end - - class << self - # pkg:gem/json#lib/json/ext.rb:11 - def parse(_arg0, _arg1); end - end -end - -# pkg:gem/json#lib/json/ext.rb:32 -JSON::Ext::Parser::Config = JSON::Ext::ParserConfig - -# pkg:gem/json#lib/json/ext.rb:31 -class JSON::Ext::ParserConfig - # pkg:gem/json#lib/json/ext.rb:31 - def initialize(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:31 - def parse(_arg0); end -end - -# Fragment of JSON document that is to be included as is: -# fragment = JSON::Fragment.new("[1, 2, 3]") -# JSON.generate({ count: 3, items: fragments }) -# -# This allows to easily assemble multiple JSON fragments that have -# been persisted somewhere without having to parse them nor resorting -# to string interpolation. -# -# Note: no validation is performed on the provided string. It is the -# responsibility of the caller to ensure the string contains valid JSON. -# -# pkg:gem/json#lib/json/common.rb:298 -class JSON::Fragment < ::Struct - # pkg:gem/json#lib/json/common.rb:299 - def initialize(json); end - - # pkg:gem/json#lib/json/common.rb:298 - def json; end - - # pkg:gem/json#lib/json/common.rb:298 - def json=(_); end - - # pkg:gem/json#lib/json/common.rb:307 - def to_json(state = T.unsafe(nil), *_arg1); end - - class << self - # pkg:gem/json#lib/json/common.rb:298 - def [](*_arg0); end - - # pkg:gem/json#lib/json/common.rb:298 - def inspect; end - - # pkg:gem/json#lib/json/common.rb:298 - def keyword_init?; end - - # pkg:gem/json#lib/json/common.rb:298 - def members; end - - # pkg:gem/json#lib/json/common.rb:298 - def new(*_arg0); end - end -end - -# This exception is raised if a generator or unparser error occurs. -# -# pkg:gem/json#lib/json/common.rb:268 -class JSON::GeneratorError < ::JSON::JSONError - # pkg:gem/json#lib/json/common.rb:271 - def initialize(message, invalid_object = T.unsafe(nil)); end - - # pkg:gem/json#lib/json/common.rb:276 - def detailed_message(*_arg0, **_arg1, &_arg2); end - - # pkg:gem/json#lib/json/common.rb:269 - def invalid_object; end -end - -# pkg:gem/json#lib/json/common.rb:1111 -module JSON::GeneratorMethods - # call-seq: to_json(*) - # - # Converts this object into a JSON string. - # If this object doesn't directly maps to a JSON native type, - # first convert it to a string (calling #to_s), then converts - # it to a JSON string, and returns the result. - # This is a fallback, if no special method #to_json was defined for some object. - # - # pkg:gem/json#lib/json/common.rb:1119 - def to_json(state = T.unsafe(nil), *_arg1); end -end - -# pkg:gem/json#lib/json/generic_object.rb:9 -class JSON::GenericObject < ::OpenStruct - # pkg:gem/json#lib/json/generic_object.rb:59 - def as_json(*_arg0); end - - # pkg:gem/json#lib/json/generic_object.rb:51 - def to_hash; end - - # pkg:gem/json#lib/json/generic_object.rb:63 - def to_json(*a); end - - # pkg:gem/json#lib/json/generic_object.rb:55 - def |(other); end - - class << self - # pkg:gem/json#lib/json/generic_object.rb:11 - def [](*_arg0); end - - # pkg:gem/json#lib/json/generic_object.rb:45 - def dump(obj, *args); end - - # pkg:gem/json#lib/json/generic_object.rb:25 - def from_hash(object); end - - # pkg:gem/json#lib/json/generic_object.rb:17 - def json_creatable=(_arg0); end - - # pkg:gem/json#lib/json/generic_object.rb:13 - def json_creatable?; end - - # pkg:gem/json#lib/json/generic_object.rb:19 - def json_create(data); end - - # pkg:gem/json#lib/json/generic_object.rb:40 - def load(source, proc = T.unsafe(nil), opts = T.unsafe(nil)); end - end -end - -# pkg:gem/json#lib/json/common.rb:367 -JSON::PARSE_L_OPTIONS = T.let(T.unsafe(nil), Hash) - -# pkg:gem/json#lib/json/common.rb:480 -JSON::PRETTY_GENERATE_OPTIONS = T.let(T.unsafe(nil), Hash) - -# pkg:gem/json#lib/json/common.rb:152 -JSON::Parser = JSON::Ext::Parser - -# This exception is raised if a parser error occurs. -# -# pkg:gem/json#lib/json/common.rb:259 -class JSON::ParserError < ::JSON::JSONError - # pkg:gem/json#lib/json/common.rb:260 - def column; end - - # pkg:gem/json#lib/json/common.rb:260 - def line; end -end - -# pkg:gem/json#lib/json/common.rb:8 -module JSON::ParserOptions - class << self - # pkg:gem/json#lib/json/common.rb:10 - def prepare(opts); end - - private - - # pkg:gem/json#lib/json/common.rb:40 - def array_class_proc(array_class, on_load); end - - # TODO: extract :create_additions support to another gem for version 3.0 - # - # pkg:gem/json#lib/json/common.rb:52 - def create_additions_proc(opts); end - - # pkg:gem/json#lib/json/common.rb:95 - def create_additions_warning; end - - # pkg:gem/json#lib/json/common.rb:29 - def object_class_proc(object_class, on_load); end - end -end - -# Not yet available on JRuby -# -# pkg:gem/json#lib/json/ext.rb:31 -class JSON::ResumableParser - # pkg:gem/json#lib/json/ext.rb:31 - def initialize(*_arg0); end - - # pkg:gem/json#lib/json/ext.rb:31 - def <<(_arg0); end - - # pkg:gem/json#lib/json/ext.rb:31 - def clear; end - - # Returns whether the parser is entirely done: no unconsumed bytes in - # the buffer, no document under construction and no parsed value - # awaiting retrieval. - # - # The main use case is detecting a truncated stream once the input is - # exhausted: - # - # loop do - # begin - # parser << socket.readpartial(4096) - # rescue EOFError - # break - # end - # while parser.parse - # process(parser.value) - # end - # end - # warn "stream was truncated" unless parser.empty? - # - # pkg:gem/json#lib/json/ext.rb:64 - def empty?; end - - # pkg:gem/json#lib/json/ext.rb:31 - def eos?; end - - # pkg:gem/json#lib/json/ext.rb:31 - def parse; end - - # pkg:gem/json#lib/json/ext.rb:31 - def parsed_bytes; end - - # pkg:gem/json#lib/json/ext.rb:31 - def partial_value; end - - # pkg:gem/json#lib/json/ext.rb:31 - def partial_value?; end - - # pkg:gem/json#lib/json/ext.rb:31 - def rest; end - - # pkg:gem/json#lib/json/ext.rb:31 - def value; end - - # pkg:gem/json#lib/json/ext.rb:31 - def value?; end -end - -# pkg:gem/json#lib/json/common.rb:182 -JSON::State = JSON::Ext::Generator::State - -# pkg:gem/json#lib/json/common.rb:1136 -module Kernel - private - - # If _object_ is string-like, parse the string and return the parsed result as - # a Ruby data structure. Otherwise, generate a JSON text from the Ruby data - # structure object and return it. - # - # The _opts_ argument is passed through to generate/parse respectively. See - # generate and parse for their documentation. - # - # pkg:gem/json#lib/json/common.rb:1175 - def JSON(object, opts = T.unsafe(nil)); end - - # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in - # one line. - # - # pkg:gem/json#lib/json/common.rb:1141 - def j(*objs); end - - # Outputs _objs_ to STDOUT as JSON strings in a pretty format, with - # indentation and over many lines. - # - # pkg:gem/json#lib/json/common.rb:1156 - def jj(*objs); end -end - -# pkg:gem/json#lib/json/common.rb:1180 -class Object < ::BasicObject - include ::Kernel - include ::PP::ObjectMixin - include ::JSON::GeneratorMethods -end diff --git a/sorbet/rbi/gems/json@3.0.2.rbi b/sorbet/rbi/gems/json@3.1.0.rbi similarity index 90% rename from sorbet/rbi/gems/json@3.0.2.rbi rename to sorbet/rbi/gems/json@3.1.0.rbi index a37f4c685..9a6e466d4 100644 --- a/sorbet/rbi/gems/json@3.0.2.rbi +++ b/sorbet/rbi/gems/json@3.1.0.rbi @@ -417,6 +417,14 @@ # When +true+, keys are sorted lexicographically. When a \Proc, it receives # the entire \Hash and must return a \Hash with its pairs in the desired # order, allowing for arbitrary sort orders. +# - Option +rfc8785+ (boolean) controls whether the generated JSON will be canonicalized +# as defined in RFC8785. +# Integers are converted to Float before formatting and may be rounded. +# Integers outside the finite Float range raise JSON::GeneratorError. +# Nonempty +indent+, +space+, +space_before+, +object_nl+, or +array_nl+, +# and enabled +ascii_only+, +script_safe+, or +allow_nan+ raise ArgumentError. +# JSON.dump defaults +allow_nan+ to +false+ when +rfc8785+ is enabled. +# JSON::Fragment contents are inserted as is; the caller must ensure they are canonical. # # In this example, +obj+ is used first to generate the shortest # \JSON data (no whitespace), then again with all formatting options @@ -478,7 +486,7 @@ module JSON # Output: # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} # - # pkg:gem/json#lib/json/common.rb:752 + # pkg:gem/json#lib/json/common.rb:747 def dump(obj, anIO = T.unsafe(nil), _deprecated_limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end # :call-seq: @@ -517,7 +525,7 @@ module JSON # # Raises JSON::NestingError (nesting of 100 is too deep. Did you try to serialize objects with circular references?): # JSON.generate(a) # - # pkg:gem/json#lib/json/common.rb:378 + # pkg:gem/json#lib/json/common.rb:373 def generate(obj, opts = T.unsafe(nil)); end # :call-seq: @@ -646,7 +654,7 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # pkg:gem/json#lib/json/common.rb:706 + # pkg:gem/json#lib/json/common.rb:701 def load(source, proc = T.unsafe(nil), allow_blank: T.unsafe(nil), **options); end # :call-seq: @@ -657,7 +665,7 @@ module JSON # # See method #parse. # - # pkg:gem/json#lib/json/common.rb:327 + # pkg:gem/json#lib/json/common.rb:322 def load_file(filespec, **options); end # :call-seq: @@ -668,7 +676,7 @@ module JSON # # See method #parse! # - # pkg:gem/json#lib/json/common.rb:338 + # pkg:gem/json#lib/json/common.rb:333 def load_file!(filespec, **options); end # :call-seq: @@ -719,7 +727,7 @@ module JSON # # Raises JSON::ParserError (unexpected character: 'invalid' at line 1 column 1): # JSON.parse('invalid') # - # pkg:gem/json#lib/json/common.rb:296 + # pkg:gem/json#lib/json/common.rb:291 def parse(source, on_load: T.unsafe(nil), object_class: T.unsafe(nil), array_class: T.unsafe(nil), **options); end # :call-seq: @@ -734,7 +742,7 @@ module JSON # which disables checking for nesting depth. # - Option +allow_nan+, if not provided, defaults to +true+. # - # pkg:gem/json#lib/json/common.rb:316 + # pkg:gem/json#lib/json/common.rb:311 def parse!(source, **options); end # :call-seq: @@ -767,7 +775,7 @@ module JSON # } # } # - # pkg:gem/json#lib/json/common.rb:424 + # pkg:gem/json#lib/json/common.rb:419 def pretty_generate(obj, opts = T.unsafe(nil)); end # :call-seq: @@ -900,7 +908,7 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # pkg:gem/json#lib/json/common.rb:576 + # pkg:gem/json#lib/json/common.rb:571 def unsafe_load(source, proc = T.unsafe(nil), **options); end class << self @@ -944,7 +952,7 @@ module JSON # Output: # {"foo":[0,1],"bar":{"baz":2,"bat":3},"bam":"bad"} # - # pkg:gem/json#lib/json/common.rb:752 + # pkg:gem/json#lib/json/common.rb:747 def dump(obj, anIO = T.unsafe(nil), _deprecated_limit = T.unsafe(nil), kwargs = T.unsafe(nil)); end # :call-seq: @@ -983,12 +991,12 @@ module JSON # # Raises JSON::NestingError (nesting of 100 is too deep. Did you try to serialize objects with circular references?): # JSON.generate(a) # - # pkg:gem/json#lib/json/common.rb:378 + # pkg:gem/json#lib/json/common.rb:373 def generate(obj, opts = T.unsafe(nil)); end # Returns the JSON generator module that is used by JSON. # - # pkg:gem/json#lib/json/common.rb:112 + # pkg:gem/json#lib/json/common.rb:104 def generator; end # Set the module _generator_ to be used by JSON. @@ -1122,7 +1130,7 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # pkg:gem/json#lib/json/common.rb:706 + # pkg:gem/json#lib/json/common.rb:701 def load(source, proc = T.unsafe(nil), allow_blank: T.unsafe(nil), **options); end # :call-seq: @@ -1133,7 +1141,7 @@ module JSON # # See method #parse. # - # pkg:gem/json#lib/json/common.rb:327 + # pkg:gem/json#lib/json/common.rb:322 def load_file(filespec, **options); end # :call-seq: @@ -1144,7 +1152,7 @@ module JSON # # See method #parse! # - # pkg:gem/json#lib/json/common.rb:338 + # pkg:gem/json#lib/json/common.rb:333 def load_file!(filespec, **options); end # :call-seq: @@ -1195,7 +1203,7 @@ module JSON # # Raises JSON::ParserError (unexpected character: 'invalid' at line 1 column 1): # JSON.parse('invalid') # - # pkg:gem/json#lib/json/common.rb:296 + # pkg:gem/json#lib/json/common.rb:291 def parse(source, on_load: T.unsafe(nil), object_class: T.unsafe(nil), array_class: T.unsafe(nil), **options); end # :call-seq: @@ -1210,7 +1218,7 @@ module JSON # which disables checking for nesting depth. # - Option +allow_nan+, if not provided, defaults to +true+. # - # pkg:gem/json#lib/json/common.rb:316 + # pkg:gem/json#lib/json/common.rb:311 def parse!(source, **options); end # Returns the JSON parser class that is used by JSON. @@ -1253,17 +1261,17 @@ module JSON # } # } # - # pkg:gem/json#lib/json/common.rb:424 + # pkg:gem/json#lib/json/common.rb:419 def pretty_generate(obj, opts = T.unsafe(nil)); end # Sets or Returns the JSON generator state class that is used by JSON. # - # pkg:gem/json#lib/json/common.rb:115 + # pkg:gem/json#lib/json/common.rb:107 def state; end # Sets or Returns the JSON generator state class that is used by JSON. # - # pkg:gem/json#lib/json/common.rb:115 + # pkg:gem/json#lib/json/common.rb:107 def state=(_arg0); end # :call-seq: @@ -1396,14 +1404,14 @@ module JSON # #"Admin", "password"=>"0wn3d"}>} # - # pkg:gem/json#lib/json/common.rb:576 + # pkg:gem/json#lib/json/common.rb:571 def unsafe_load(source, proc = T.unsafe(nil), **options); end private # Called from the extension when a hash has both string and symbol keys # - # pkg:gem/json#lib/json/common.rb:120 + # pkg:gem/json#lib/json/common.rb:112 def on_mixed_keys_hash(hash); end end end @@ -1418,7 +1426,7 @@ end # # MyApp::JSONC_CODER.load(document) # -# pkg:gem/json#lib/json/common.rb:792 +# pkg:gem/json#lib/json/common.rb:787 class JSON::Coder # :call-seq: # JSON::Coder.new(**options, &block) @@ -1444,8 +1452,11 @@ class JSON::Coder # # puts MyApp::API_JSON_CODER.dump(Time.now.utc) # => "2025-01-21T08:41:44.286Z" # - # pkg:gem/json#lib/json/common.rb:838 - def initialize(object_class: T.unsafe(nil), array_class: T.unsafe(nil), on_load: T.unsafe(nil), **options, &as_json); end + # The conversion callback can also be passed as +as_json:+. If both are given, the block takes precedence. + # Passing +false+ or +nil+ for +strict:+ raises ArgumentError. + # + # pkg:gem/json#lib/json/common.rb:836 + def initialize(object_class: T.unsafe(nil), array_class: T.unsafe(nil), on_load: T.unsafe(nil), strict: T.unsafe(nil), **options, &as_json); end # call-seq: # dump(object) -> String @@ -1479,13 +1490,33 @@ class JSON::Coder def parse(source); end end -# pkg:gem/json#lib/json/common.rb:807 +# pkg:gem/json#lib/json/common.rb:802 JSON::Coder::EXCLUDED_GENERATOR_OPTIONS = T.let(T.unsafe(nil), Array) -# pkg:gem/json#lib/json/common.rb:793 +# pkg:gem/json#lib/json/common.rb:788 JSON::Coder::PARSER_OPTIONS = T.let(T.unsafe(nil), Array) -# pkg:gem/json#lib/json/ext.rb:39 +# This module holds all the modules/classes that implement JSON's +# functionality as C extensions. +# +# pkg:gem/json#lib/json/ext.rb:8 +module JSON::Ext + class << self + # pkg:gem/json#lib/json/ext.rb:46 + def coerce_key(key, as_json); end + + # pkg:gem/json#lib/json/ext.rb:80 + def on_duplicate_key(hash, as_json); end + + # pkg:gem/json#lib/json/ext.rb:33 + def shareable_lambda(block); end + + # pkg:gem/json#lib/json/ext.rb:42 + def valid_encoding?(str); end + end +end + +# pkg:gem/json#lib/json/ext.rb:101 class JSON::Ext::Generator::State # call-seq: new(opts = {}) # @@ -1494,43 +1525,43 @@ class JSON::Ext::Generator::State # Argument +opts+, if given, contains a \Hash of options for the generation. # See {Generating Options}[rdoc-ref:JSON@Generating+Options]. # - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def initialize(opts = T.unsafe(nil)); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def _generate_no_fallback(*_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def allow_nan=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def allow_nan?; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def array_nl; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def array_nl=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def as_json; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def as_json=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def ascii_only=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def ascii_only?; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def buffer_initial_length; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def buffer_initial_length=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def check_circular?; end # call-seq: configure(opts) @@ -1541,70 +1572,76 @@ class JSON::Ext::Generator::State # pkg:gem/json#lib/json/ext/generator/state.rb:23 def configure(opts); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def depth; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def depth=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def generate(*_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def indent; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def indent=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def max_nesting; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def max_nesting=(_arg0); end # pkg:gem/json#lib/json/ext/generator/state.rb:36 def merge(opts); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def object_nl; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def object_nl=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 + def rfc8785=(_arg0); end + + # pkg:gem/json#lib/json/ext.rb:101 + def rfc8785?; end + + # pkg:gem/json#lib/json/ext.rb:101 def script_safe; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def script_safe=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def script_safe?; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def sort_keys; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def sort_keys=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def space; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def space=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def space_before; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def space_before=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def strict; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def strict=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def strict?; end # call-seq: to_h @@ -1615,32 +1652,38 @@ class JSON::Ext::Generator::State # pkg:gem/json#lib/json/ext/generator/state.rb:42 def to_h; end - # pkg:gem/json#lib/json/ext/generator/state.rb:73 + # pkg:gem/json#lib/json/ext/generator/state.rb:69 def to_hash; end private - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def _configure(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def allow_duplicate_key?; end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def initialize_copy(_arg0); end class << self - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def _generate_no_fallback(_arg0, _arg1, _arg2); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def default_sort_keys_proc=(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def from_state(_arg0); end - # pkg:gem/json#lib/json/ext.rb:39 + # pkg:gem/json#lib/json/ext.rb:101 def generate(_arg0, _arg1, _arg2); end + + # pkg:gem/json#lib/json/ext.rb:101 + def rfc8785_number_formatter_proc=(_arg0); end + + # pkg:gem/json#lib/json/ext.rb:101 + def rfc8785_sort_keys_proc=(_arg0); end end end @@ -1661,15 +1704,15 @@ class JSON::Ext::Parser end end -# pkg:gem/json#lib/json/ext.rb:32 +# pkg:gem/json#lib/json/ext.rb:94 JSON::Ext::Parser::Config = JSON::Ext::ParserConfig -# pkg:gem/json#lib/json/ext.rb:31 +# pkg:gem/json#lib/json/ext.rb:93 class JSON::Ext::ParserConfig - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def initialize(_arg0); end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def parse(_arg0); end end @@ -1684,49 +1727,49 @@ end # Note: no validation is performed on the provided string. It is the # responsibility of the caller to ensure the string contains valid JSON. # -# pkg:gem/json#lib/json/common.rb:232 +# pkg:gem/json#lib/json/common.rb:227 class JSON::Fragment < ::Struct - # pkg:gem/json#lib/json/common.rb:233 + # pkg:gem/json#lib/json/common.rb:228 def initialize(json); end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def json; end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def json=(_); end - # pkg:gem/json#lib/json/common.rb:241 + # pkg:gem/json#lib/json/common.rb:236 def to_json(state = T.unsafe(nil), *); end class << self - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def [](*_arg0); end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def inspect; end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def keyword_init?; end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def members; end - # pkg:gem/json#lib/json/common.rb:232 + # pkg:gem/json#lib/json/common.rb:227 def new(*_arg0); end end end # This exception is raised if a generator or unparser error occurs. # -# pkg:gem/json#lib/json/common.rb:202 +# pkg:gem/json#lib/json/common.rb:197 class JSON::GeneratorError < ::JSON::JSONError - # pkg:gem/json#lib/json/common.rb:205 + # pkg:gem/json#lib/json/common.rb:200 def initialize(message, invalid_object = T.unsafe(nil)); end - # pkg:gem/json#lib/json/common.rb:210 + # pkg:gem/json#lib/json/common.rb:205 def detailed_message(*, **, &); end - # pkg:gem/json#lib/json/common.rb:203 + # pkg:gem/json#lib/json/common.rb:198 def invalid_object; end end @@ -1744,7 +1787,7 @@ module JSON::GeneratorMethods def to_json(state = T.unsafe(nil), *); end end -# pkg:gem/json#lib/json/common.rb:386 +# pkg:gem/json#lib/json/common.rb:381 JSON::PRETTY_GENERATE_OPTIONS = T.let(T.unsafe(nil), Hash) # pkg:gem/json#lib/json/common.rb:76 @@ -1752,12 +1795,12 @@ JSON::Parser = JSON::Ext::Parser # This exception is raised if a parser error occurs. # -# pkg:gem/json#lib/json/common.rb:144 +# pkg:gem/json#lib/json/common.rb:136 class JSON::ParserError < ::JSON::JSONError - # Column number where the parser encountered an error. + # One-based column number where the parser encountered an error, counted in Unicode codepoints. # Is +nil+ when raised by JSON::ResumableParser. # - # pkg:gem/json#lib/json/common.rb:151 + # pkg:gem/json#lib/json/common.rb:143 def column; end # Returns a best effort JSONPath string representing where in the document @@ -1769,18 +1812,18 @@ class JSON::ParserError < ::JSON::JSONError # error.json_path # => "$.articles[0].title" # end # - # pkg:gem/json#lib/json/common.rb:161 + # pkg:gem/json#lib/json/common.rb:153 def json_path; end # Line number where the parser encountered an error. # Is +nil+ when raised by JSON::ResumableParser. # - # pkg:gem/json#lib/json/common.rb:147 + # pkg:gem/json#lib/json/common.rb:139 def line; end private - # pkg:gem/json#lib/json/common.rb:173 + # pkg:gem/json#lib/json/common.rb:165 def build_json_path(segments); end end @@ -1802,15 +1845,15 @@ end # Not yet available on JRuby # -# pkg:gem/json#lib/json/ext.rb:31 +# pkg:gem/json#lib/json/ext.rb:93 class JSON::ResumableParser - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def initialize(*_arg0); end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def <<(_arg0); end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def clear; end # Returns whether the parser is entirely done: no unconsumed bytes in @@ -1832,35 +1875,35 @@ class JSON::ResumableParser # end # warn "stream was truncated" unless parser.empty? # - # pkg:gem/json#lib/json/ext.rb:64 + # pkg:gem/json#lib/json/ext.rb:190 def empty?; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def eos?; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def parse; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def parsed_bytes; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def partial_value; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def partial_value?; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def rest; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def value; end - # pkg:gem/json#lib/json/ext.rb:31 + # pkg:gem/json#lib/json/ext.rb:93 def value?; end end -# pkg:gem/json#lib/json/common.rb:106 +# pkg:gem/json#lib/json/common.rb:98 JSON::State = JSON::Ext::Generator::State # pkg:gem/json#lib/json/common.rb:907 diff --git a/sorbet/rbi/gems/parallel@2.2.0.rbi b/sorbet/rbi/gems/parallel@2.3.0.rbi similarity index 95% rename from sorbet/rbi/gems/parallel@2.2.0.rbi rename to sorbet/rbi/gems/parallel@2.3.0.rbi index 036558941..77e77e17e 100644 --- a/sorbet/rbi/gems/parallel@2.2.0.rbi +++ b/sorbet/rbi/gems/parallel@2.3.0.rbi @@ -21,10 +21,10 @@ module Parallel def each_with_index(array, options = T.unsafe(nil), &block); end # pkg:gem/parallel#lib/parallel.rb:333 - def filter_map(*_arg0, **_arg1, &_arg2); end + def filter_map(*, **, &); end # pkg:gem/parallel#lib/parallel.rb:329 - def flat_map(*_arg0, **_arg1, &_arg2); end + def flat_map(*, **, &); end # pkg:gem/parallel#lib/parallel.rb:241 def in_processes(options = T.unsafe(nil), &block); end @@ -62,10 +62,10 @@ module Parallel # pkg:gem/parallel#lib/parallel.rb:410 def add_progress_bar!(job_factory, options); end - # pkg:gem/parallel#lib/parallel.rb:797 + # pkg:gem/parallel#lib/parallel.rb:800 def available_processor_count; end - # pkg:gem/parallel#lib/parallel.rb:745 + # pkg:gem/parallel#lib/parallel.rb:748 def call_with_index(item, index, options, &block); end # pkg:gem/parallel#lib/parallel.rb:655 @@ -73,26 +73,26 @@ module Parallel # options is either a Integer or a Hash with :count # - # pkg:gem/parallel#lib/parallel.rb:735 + # pkg:gem/parallel#lib/parallel.rb:738 def extract_count_from_options(options); end - # pkg:gem/parallel#lib/parallel.rb:763 + # pkg:gem/parallel#lib/parallel.rb:766 def instrument_finish(item, index, result, options); end # yield results in the order of the input items # needs to use `options` to store state between executions # needs to use `done` index since a nil result would also be valid # - # pkg:gem/parallel#lib/parallel.rb:772 + # pkg:gem/parallel#lib/parallel.rb:775 def instrument_finish_in_order(item, index, result, options); end - # pkg:gem/parallel#lib/parallel.rb:792 + # pkg:gem/parallel#lib/parallel.rb:795 def instrument_start(item, index, options); end # pkg:gem/parallel#lib/parallel.rb:383 def physical_processor_count_windows; end - # pkg:gem/parallel#lib/parallel.rb:710 + # pkg:gem/parallel#lib/parallel.rb:713 def process_incoming_jobs(read, write, job_factory, options, &block); end # ractors cannot execute blocks, so run the callback directly when not using ractors @@ -118,7 +118,7 @@ module Parallel # pkg:gem/parallel#lib/parallel.rb:404 def run(command); end - # pkg:gem/parallel#lib/parallel.rb:756 + # pkg:gem/parallel#lib/parallel.rb:759 def with_instrumentation(item, index, options); end # pkg:gem/parallel#lib/parallel.rb:435 diff --git a/sorbet/rbi/gems/rbi@0.4.3.rbi b/sorbet/rbi/gems/rbi@0.5.0.rbi similarity index 88% rename from sorbet/rbi/gems/rbi@0.4.3.rbi rename to sorbet/rbi/gems/rbi@0.5.0.rbi index 66530354b..99744b58c 100644 --- a/sorbet/rbi/gems/rbi@0.4.3.rbi +++ b/sorbet/rbi/gems/rbi@0.5.0.rbi @@ -14,21 +14,21 @@ # pkg:gem/rbi#lib/rbi.rb:7 module RBI; end -# pkg:gem/rbi#lib/rbi/model.rb:1011 +# pkg:gem/rbi#lib/rbi/model.rb:1048 class RBI::Arg < ::RBI::Node - # pkg:gem/rbi#lib/rbi/model.rb:1016 + # pkg:gem/rbi#lib/rbi/model.rb:1053 sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void } def initialize(value, loc: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:1022 + # pkg:gem/rbi#lib/rbi/model.rb:1059 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1027 + # pkg:gem/rbi#lib/rbi/model.rb:1064 sig { returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:1013 + # pkg:gem/rbi#lib/rbi/model.rb:1050 sig { returns(::String) } def value; end end @@ -56,7 +56,7 @@ class RBI::Attr < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:420 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:435 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -80,7 +80,7 @@ class RBI::Attr < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:429 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:444 sig { override.params(other: ::RBI::Node).void } def merge_with(other); end @@ -105,7 +105,8 @@ class RBI::Attr < ::RBI::NodeWithComments def visibility; end # pkg:gem/rbi#lib/rbi/model.rb:330 - def visibility=(_arg0); end + sig { params(visibility: ::RBI::Visibility).returns(::RBI::Visibility) } + def visibility=(visibility); end private @@ -159,7 +160,7 @@ class RBI::AttrAccessor < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:458 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:473 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -200,7 +201,7 @@ class RBI::AttrReader < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:442 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:457 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -241,7 +242,7 @@ class RBI::AttrWriter < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:450 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:465 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -273,9 +274,9 @@ class RBI::BlankLine < ::RBI::Comment def initialize(loc: T.unsafe(nil)); end end -# pkg:gem/rbi#lib/rbi/model.rb:843 +# pkg:gem/rbi#lib/rbi/model.rb:848 class RBI::BlockParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:849 + # pkg:gem/rbi#lib/rbi/model.rb:854 sig do params( name: T.nilable(::String), @@ -286,25 +287,25 @@ class RBI::BlockParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:868 + # pkg:gem/rbi#lib/rbi/model.rb:873 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:863 + # pkg:gem/rbi#lib/rbi/model.rb:868 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:846 + # pkg:gem/rbi#lib/rbi/model.rb:851 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:857 + # pkg:gem/rbi#lib/rbi/model.rb:862 sig { override.returns(::String) } def to_s; end end @@ -325,7 +326,7 @@ class RBI::Class < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:388 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:403 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -344,7 +345,8 @@ class RBI::Class < ::RBI::Scope def superclass_name; end # pkg:gem/rbi#lib/rbi/model.rb:222 - def superclass_name=(_arg0); end + sig { params(superclass_name: T.nilable(::String)).returns(T.nilable(::String)) } + def superclass_name=(superclass_name); end end # pkg:gem/rbi#lib/rbi/model.rb:51 @@ -362,7 +364,8 @@ class RBI::Comment < ::RBI::Node def text; end # pkg:gem/rbi#lib/rbi/model.rb:53 - def text=(_arg0); end + sig { params(text: ::String).returns(::String) } + def text=(text); end end # A tree showing incompatibles nodes @@ -380,24 +383,24 @@ end # end # ~~~ # -# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:634 +# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:661 class RBI::ConflictTree < ::RBI::Tree - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:642 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:669 sig { params(left_name: ::String, right_name: ::String).void } def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:636 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:663 sig { returns(::RBI::Tree) } def left; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:639 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:666 sig { returns(::String) } def left_name; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:636 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:663 def right; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:639 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:666 def right_name; end end @@ -421,7 +424,7 @@ class RBI::Const < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:412 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:427 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -449,17 +452,17 @@ class RBI::Const < ::RBI::NodeWithComments def value; end end -# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:358 +# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:373 class RBI::DuplicateNodeError < ::RBI::Error; end # pkg:gem/rbi#lib/rbi.rb:8 class RBI::Error < ::StandardError; end -# pkg:gem/rbi#lib/rbi/model.rb:901 +# pkg:gem/rbi#lib/rbi/model.rb:938 class RBI::Extend < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:903 + # pkg:gem/rbi#lib/rbi/model.rb:940 sig do params( name: ::String, @@ -473,7 +476,7 @@ class RBI::Extend < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:567 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:594 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -485,7 +488,7 @@ class RBI::Extend < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:910 + # pkg:gem/rbi#lib/rbi/model.rb:947 sig { override.returns(::String) } def to_s; end end @@ -522,7 +525,7 @@ class RBI::File sig { returns(T::Boolean) } def empty?; end - # pkg:gem/rbi#lib/rbi/printer.rb:866 + # pkg:gem/rbi#lib/rbi/printer.rb:872 sig do params( out: T.any(::IO, ::StringIO), @@ -533,11 +536,11 @@ class RBI::File end def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1218 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1224 sig { params(out: T.any(::IO, ::StringIO), indent: ::Integer, print_locs: T::Boolean).void } def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1224 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1230 sig { params(indent: ::Integer, print_locs: T::Boolean).returns(::String) } def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end @@ -546,16 +549,18 @@ class RBI::File def root; end # pkg:gem/rbi#lib/rbi/model.rb:145 - def root=(_arg0); end + sig { params(root: ::RBI::Tree).returns(::RBI::Tree) } + def root=(root); end # pkg:gem/rbi#lib/rbi/model.rb:148 sig { returns(T.nilable(::String)) } def strictness; end # pkg:gem/rbi#lib/rbi/model.rb:148 - def strictness=(_arg0); end + sig { params(strictness: T.nilable(::String)).returns(T.nilable(::String)) } + def strictness=(strictness); end - # pkg:gem/rbi#lib/rbi/printer.rb:872 + # pkg:gem/rbi#lib/rbi/printer.rb:878 sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end end @@ -589,13 +594,51 @@ class RBI::Formatter def max_line_length; end # pkg:gem/rbi#lib/rbi/formatter.rb:7 - def max_line_length=(_arg0); end + sig { params(max_line_length: T.nilable(::Integer)).returns(T.nilable(::Integer)) } + def max_line_length=(max_line_length); end # pkg:gem/rbi#lib/rbi/formatter.rb:37 sig { params(file: ::RBI::File).returns(::String) } def print_file(file); end end +# The `...` in `def m(...)` +# +# pkg:gem/rbi#lib/rbi/model.rb:879 +class RBI::ForwardingParam < ::RBI::Param + # pkg:gem/rbi#lib/rbi/model.rb:887 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T.nilable(T::Array[::RBI::Comment]), + block: T.nilable(T.proc.params(node: ::RBI::ForwardingParam).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # pkg:gem/rbi#lib/rbi/model.rb:905 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # @override + # + # pkg:gem/rbi#lib/rbi/model.rb:900 + sig { override.returns(T::Boolean) } + def anonymous?; end + + # @override + # + # pkg:gem/rbi#lib/rbi/model.rb:882 + sig { override.returns(::NilClass) } + def name; end + + # @override + # + # pkg:gem/rbi#lib/rbi/model.rb:894 + sig { override.returns(::String) } + def to_s; end +end + # pkg:gem/rbi#lib/rbi/rewriters/group_nodes.rb:86 class RBI::Group < ::RBI::Tree # pkg:gem/rbi#lib/rbi/rewriters/group_nodes.rb:91 @@ -661,11 +704,11 @@ class RBI::GroupNodesError < ::RBI::Error; end # Sorbet's misc. # -# pkg:gem/rbi#lib/rbi/model.rb:1349 +# pkg:gem/rbi#lib/rbi/model.rb:1386 class RBI::Helper < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1354 + # pkg:gem/rbi#lib/rbi/model.rb:1391 sig do params( name: ::String, @@ -678,7 +721,7 @@ class RBI::Helper < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:583 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:610 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -688,22 +731,22 @@ class RBI::Helper < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1351 + # pkg:gem/rbi#lib/rbi/model.rb:1388 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1362 + # pkg:gem/rbi#lib/rbi/model.rb:1399 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:887 +# pkg:gem/rbi#lib/rbi/model.rb:924 class RBI::Include < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:889 + # pkg:gem/rbi#lib/rbi/model.rb:926 sig do params( name: ::String, @@ -717,7 +760,7 @@ class RBI::Include < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:559 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:586 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -729,7 +772,7 @@ class RBI::Include < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:896 + # pkg:gem/rbi#lib/rbi/model.rb:933 sig { override.returns(::String) } def to_s; end end @@ -789,28 +832,28 @@ module RBI::Indexable def index_ids; end end -# pkg:gem/rbi#lib/rbi/model.rb:1032 +# pkg:gem/rbi#lib/rbi/model.rb:1069 class RBI::KwArg < ::RBI::Arg - # pkg:gem/rbi#lib/rbi/model.rb:1037 + # pkg:gem/rbi#lib/rbi/model.rb:1074 sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void } def initialize(keyword, value, loc: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:1043 + # pkg:gem/rbi#lib/rbi/model.rb:1080 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1034 + # pkg:gem/rbi#lib/rbi/model.rb:1071 sig { returns(::String) } def keyword; end - # pkg:gem/rbi#lib/rbi/model.rb:1048 + # pkg:gem/rbi#lib/rbi/model.rb:1085 sig { returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:754 +# pkg:gem/rbi#lib/rbi/model.rb:759 class RBI::KwOptParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:763 + # pkg:gem/rbi#lib/rbi/model.rb:768 sig do params( name: ::String, @@ -822,36 +865,36 @@ class RBI::KwOptParam < ::RBI::Param end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:783 + # pkg:gem/rbi#lib/rbi/model.rb:788 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:778 + # pkg:gem/rbi#lib/rbi/model.rb:783 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:757 + # pkg:gem/rbi#lib/rbi/model.rb:762 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:772 + # pkg:gem/rbi#lib/rbi/model.rb:777 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:760 + # pkg:gem/rbi#lib/rbi/model.rb:765 sig { returns(::String) } def value; end end -# pkg:gem/rbi#lib/rbi/model.rb:724 +# pkg:gem/rbi#lib/rbi/model.rb:729 class RBI::KwParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:730 + # pkg:gem/rbi#lib/rbi/model.rb:735 sig do params( name: ::String, @@ -862,32 +905,32 @@ class RBI::KwParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:749 + # pkg:gem/rbi#lib/rbi/model.rb:754 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:744 + # pkg:gem/rbi#lib/rbi/model.rb:749 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:727 + # pkg:gem/rbi#lib/rbi/model.rb:732 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:738 + # pkg:gem/rbi#lib/rbi/model.rb:743 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:788 +# pkg:gem/rbi#lib/rbi/model.rb:793 class RBI::KwRestParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:794 + # pkg:gem/rbi#lib/rbi/model.rb:799 sig do params( name: T.nilable(::String), @@ -898,25 +941,25 @@ class RBI::KwRestParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:813 + # pkg:gem/rbi#lib/rbi/model.rb:818 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:808 + # pkg:gem/rbi#lib/rbi/model.rb:813 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:791 + # pkg:gem/rbi#lib/rbi/model.rb:796 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:802 + # pkg:gem/rbi#lib/rbi/model.rb:807 sig { override.returns(::String) } def to_s; end end @@ -977,9 +1020,9 @@ end # A tree that _might_ contain conflicts # -# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:342 +# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:357 class RBI::MergeTree < ::RBI::Tree - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:351 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:366 sig do params( loc: T.nilable(::RBI::Loc), @@ -990,7 +1033,7 @@ class RBI::MergeTree < ::RBI::Tree end def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), conflicts: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:344 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:359 sig { returns(T::Array[::RBI::Rewriters::Merge::Conflict]) } def conflicts; end end @@ -1024,6 +1067,10 @@ class RBI::Method < ::RBI::NodeWithComments sig { params(name: ::String).void } def add_block_param(name); end + # pkg:gem/rbi#lib/rbi/model.rb:556 + sig { void } + def add_forwarding_param; end + # pkg:gem/rbi#lib/rbi/model.rb:536 sig { params(name: ::String, default_value: ::String).void } def add_kw_opt_param(name, default_value); end @@ -1052,7 +1099,7 @@ class RBI::Method < ::RBI::NodeWithComments sig { params(name: ::String).void } def add_rest_param(name); end - # pkg:gem/rbi#lib/rbi/model.rb:565 + # pkg:gem/rbi#lib/rbi/model.rb:570 sig do params( params: T.nilable(T::Array[::RBI::SigParam]), @@ -1071,11 +1118,11 @@ class RBI::Method < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:466 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:481 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:593 + # pkg:gem/rbi#lib/rbi/model.rb:598 sig { returns(::String) } def fully_qualified_name; end @@ -1090,11 +1137,12 @@ class RBI::Method < ::RBI::NodeWithComments def is_singleton; end # pkg:gem/rbi#lib/rbi/model.rb:464 - def is_singleton=(_arg0); end + sig { params(is_singleton: T::Boolean).returns(T::Boolean) } + def is_singleton=(is_singleton); end # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:482 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:500 sig { override.params(other: ::RBI::Node).void } def merge_with(other); end @@ -1120,7 +1168,7 @@ class RBI::Method < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/model.rb:603 + # pkg:gem/rbi#lib/rbi/model.rb:608 sig { override.returns(::String) } def to_s; end @@ -1129,28 +1177,33 @@ class RBI::Method < ::RBI::NodeWithComments def visibility; end # pkg:gem/rbi#lib/rbi/model.rb:467 - def visibility=(_arg0); end + sig { params(visibility: ::RBI::Visibility).returns(::RBI::Visibility) } + def visibility=(visibility); end private - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:504 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:523 sig { params(other: ::RBI::Method).returns(T::Boolean) } def compatible_params?(other); end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:513 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:534 sig { params(preferred: T::Array[::RBI::Param], fallback: T::Array[::RBI::Param]).returns(T::Array[::RBI::Param]) } def merge_params(preferred, fallback); end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:524 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:546 + sig { params(params: T::Array[::RBI::Param]).returns(T::Boolean) } + def params_have_forwarding?(params); end + + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:551 sig { params(sigs: T::Array[::RBI::Sig], params: T::Array[::RBI::Param]).void } def rename_sigs_params(sigs, params); end end -# pkg:gem/rbi#lib/rbi/model.rb:1393 +# pkg:gem/rbi#lib/rbi/model.rb:1430 class RBI::MixesInClassMethods < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1400 + # pkg:gem/rbi#lib/rbi/model.rb:1437 sig do params( name: ::String, @@ -1164,7 +1217,7 @@ class RBI::MixesInClassMethods < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:575 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:602 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -1176,18 +1229,18 @@ class RBI::MixesInClassMethods < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1407 + # pkg:gem/rbi#lib/rbi/model.rb:1444 sig { override.returns(::String) } def to_s; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:876 +# pkg:gem/rbi#lib/rbi/model.rb:913 class RBI::Mixin < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:881 + # pkg:gem/rbi#lib/rbi/model.rb:918 sig do params( name: ::String, @@ -1200,11 +1253,11 @@ class RBI::Mixin < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:551 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:578 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:878 + # pkg:gem/rbi#lib/rbi/model.rb:915 sig { returns(T::Array[::String]) } def names; end end @@ -1224,7 +1277,7 @@ class RBI::Module < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:396 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:411 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -1239,9 +1292,9 @@ class RBI::Module < ::RBI::Scope def name; end end -# pkg:gem/rbi#lib/rbi/model.rb:818 +# pkg:gem/rbi#lib/rbi/model.rb:823 class RBI::NoKwParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:820 + # pkg:gem/rbi#lib/rbi/model.rb:825 sig do params( loc: T.nilable(::RBI::Loc), @@ -1251,19 +1304,19 @@ class RBI::NoKwParam < ::RBI::Param end def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:838 + # pkg:gem/rbi#lib/rbi/model.rb:843 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:833 + # pkg:gem/rbi#lib/rbi/model.rb:838 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:827 + # pkg:gem/rbi#lib/rbi/model.rb:832 sig { override.returns(::String) } def to_s; end end @@ -1293,7 +1346,8 @@ class RBI::Node def loc; end # pkg:gem/rbi#lib/rbi/model.rb:13 - def loc=(_arg0); end + sig { params(loc: T.nilable(::RBI::Loc)).returns(T.nilable(::RBI::Loc)) } + def loc=(loc); end # Merge `self` and `other` into a single definition # @@ -1314,9 +1368,10 @@ class RBI::Node def parent_tree; end # pkg:gem/rbi#lib/rbi/model.rb:10 - def parent_tree=(_arg0); end + sig { params(parent_tree: T.nilable(::RBI::Tree)).returns(T.nilable(::RBI::Tree)) } + def parent_tree=(parent_tree); end - # pkg:gem/rbi#lib/rbi/printer.rb:884 + # pkg:gem/rbi#lib/rbi/printer.rb:890 sig do params( out: T.any(::IO, ::StringIO), @@ -1327,7 +1382,7 @@ class RBI::Node end def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1233 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1239 sig do params( out: T.any(::IO, ::StringIO), @@ -1338,7 +1393,7 @@ class RBI::Node end def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1239 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1245 sig { params(indent: ::Integer, print_locs: T::Boolean, positional_names: T::Boolean).returns(::String) } def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil)); end @@ -1350,7 +1405,7 @@ class RBI::Node sig { params(version: ::Gem::Version).returns(T::Boolean) } def satisfies_version?(version); end - # pkg:gem/rbi#lib/rbi/printer.rb:890 + # pkg:gem/rbi#lib/rbi/printer.rb:896 sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end end @@ -1393,11 +1448,17 @@ class RBI::NodeWithComments < ::RBI::Node # pkg:gem/rbi#lib/rbi/rewriters/filter_versions.rb:101 sig { returns(T::Array[::Gem::Requirement]) } def version_requirements; end + + private + + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:340 + sig { params(index: T::Hash[::String, T::Array[::RBI::Comment]], comment: ::RBI::Comment).returns(T::Boolean) } + def index_comment(index, comment); end end -# pkg:gem/rbi#lib/rbi/model.rb:660 +# pkg:gem/rbi#lib/rbi/model.rb:665 class RBI::OptParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:669 + # pkg:gem/rbi#lib/rbi/model.rb:674 sig do params( name: ::String, @@ -1409,56 +1470,56 @@ class RBI::OptParam < ::RBI::Param end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:689 + # pkg:gem/rbi#lib/rbi/model.rb:694 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:684 + # pkg:gem/rbi#lib/rbi/model.rb:689 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:663 + # pkg:gem/rbi#lib/rbi/model.rb:668 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:678 + # pkg:gem/rbi#lib/rbi/model.rb:683 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:666 + # pkg:gem/rbi#lib/rbi/model.rb:671 sig { returns(::String) } def value; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:609 +# pkg:gem/rbi#lib/rbi/model.rb:614 class RBI::Param < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:611 + # pkg:gem/rbi#lib/rbi/model.rb:616 sig { params(loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end # @abstract # - # pkg:gem/rbi#lib/rbi/model.rb:625 + # pkg:gem/rbi#lib/rbi/model.rb:630 sig { abstract.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:543 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:570 sig { override.params(other: T.nilable(::RBI::Node)).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:616 + # pkg:gem/rbi#lib/rbi/model.rb:621 sig { returns(T.nilable(::String)) } def name; end end @@ -1509,66 +1570,66 @@ class RBI::Parser end end -# pkg:gem/rbi#lib/rbi/parser.rb:1044 +# pkg:gem/rbi#lib/rbi/parser.rb:1048 class RBI::Parser::HeredocLocationVisitor < ::Prism::Visitor - # pkg:gem/rbi#lib/rbi/parser.rb:1046 + # pkg:gem/rbi#lib/rbi/parser.rb:1050 sig { params(source: ::Prism::Source, begin_offset: ::Integer, end_offset: ::Integer).void } def initialize(source, begin_offset, end_offset); end - # pkg:gem/rbi#lib/rbi/parser.rb:1077 + # pkg:gem/rbi#lib/rbi/parser.rb:1081 sig { returns(::Prism::Location) } def location; end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:1067 + # pkg:gem/rbi#lib/rbi/parser.rb:1071 sig { override.params(node: ::Prism::InterpolatedStringNode).void } def visit_interpolated_string_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:1056 + # pkg:gem/rbi#lib/rbi/parser.rb:1060 sig { override.params(node: ::Prism::StringNode).void } def visit_string_node(node); end private - # pkg:gem/rbi#lib/rbi/parser.rb:1088 + # pkg:gem/rbi#lib/rbi/parser.rb:1092 sig { params(node: T.any(::Prism::InterpolatedStringNode, ::Prism::StringNode)).void } def handle_string_node(node); end end -# pkg:gem/rbi#lib/rbi/parser.rb:935 +# pkg:gem/rbi#lib/rbi/parser.rb:939 class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor - # pkg:gem/rbi#lib/rbi/parser.rb:940 + # pkg:gem/rbi#lib/rbi/parser.rb:944 sig { params(content: ::String, file: ::String).void } def initialize(content, file:); end - # pkg:gem/rbi#lib/rbi/parser.rb:1027 + # pkg:gem/rbi#lib/rbi/parser.rb:1031 sig { params(node: ::Prism::CallNode, value: ::String).returns(T::Boolean) } def allow_incompatible_override?(node, value); end - # pkg:gem/rbi#lib/rbi/parser.rb:937 + # pkg:gem/rbi#lib/rbi/parser.rb:941 sig { returns(::RBI::Sig) } def current; end - # pkg:gem/rbi#lib/rbi/parser.rb:1017 + # pkg:gem/rbi#lib/rbi/parser.rb:1021 sig { params(node: ::Prism::Node).returns(::String) } def sig_param_name(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:1006 + # pkg:gem/rbi#lib/rbi/parser.rb:1010 sig { params(node: ::Prism::CallNode).returns(T.nilable(::String)) } def sig_type_argument(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:998 + # pkg:gem/rbi#lib/rbi/parser.rb:1002 sig { override.params(node: ::Prism::AssocNode).void } def visit_assoc_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:948 + # pkg:gem/rbi#lib/rbi/parser.rb:952 sig { override.params(node: ::Prism::CallNode).void } def visit_call_node(node); end end @@ -1647,43 +1708,43 @@ class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor # Collect all the remaining comments after visiting the tree # - # pkg:gem/rbi#lib/rbi/parser.rb:572 + # pkg:gem/rbi#lib/rbi/parser.rb:571 sig { void } def collect_orphan_comments; end - # pkg:gem/rbi#lib/rbi/parser.rb:595 + # pkg:gem/rbi#lib/rbi/parser.rb:594 sig { returns(::RBI::Tree) } def current_scope; end - # pkg:gem/rbi#lib/rbi/parser.rb:600 + # pkg:gem/rbi#lib/rbi/parser.rb:599 sig { returns(T::Array[::RBI::Sig]) } def current_sigs; end - # pkg:gem/rbi#lib/rbi/parser.rb:607 + # pkg:gem/rbi#lib/rbi/parser.rb:606 sig { params(sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) } def detach_comments_from_sigs(sigs); end - # pkg:gem/rbi#lib/rbi/parser.rb:619 + # pkg:gem/rbi#lib/rbi/parser.rb:618 sig { params(node: ::Prism::Node).returns(T::Array[::RBI::Comment]) } def node_comments(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:681 + # pkg:gem/rbi#lib/rbi/parser.rb:680 sig { params(node: ::Prism::Comment).returns(::RBI::Comment) } def parse_comment(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:714 + # pkg:gem/rbi#lib/rbi/parser.rb:713 sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Param]) } def parse_params(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:688 + # pkg:gem/rbi#lib/rbi/parser.rb:687 sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Arg]) } def parse_send_args(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:785 + # pkg:gem/rbi#lib/rbi/parser.rb:789 sig { params(node: ::Prism::CallNode).returns(::RBI::Sig) } def parse_sig(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:794 + # pkg:gem/rbi#lib/rbi/parser.rb:798 sig do params( node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode) @@ -1691,27 +1752,27 @@ class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor end def parse_struct(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:842 + # pkg:gem/rbi#lib/rbi/parser.rb:846 sig { params(send: ::Prism::CallNode).void } def parse_tstruct_field(send); end - # pkg:gem/rbi#lib/rbi/parser.rb:879 + # pkg:gem/rbi#lib/rbi/parser.rb:883 sig { params(name: ::String, node: ::Prism::Node).returns(::RBI::Visibility) } def parse_visibility(name, node); end - # pkg:gem/rbi#lib/rbi/parser.rb:893 + # pkg:gem/rbi#lib/rbi/parser.rb:897 sig { void } def separate_header_comments; end - # pkg:gem/rbi#lib/rbi/parser.rb:903 + # pkg:gem/rbi#lib/rbi/parser.rb:907 sig { void } def set_root_tree_loc; end - # pkg:gem/rbi#lib/rbi/parser.rb:922 + # pkg:gem/rbi#lib/rbi/parser.rb:926 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_enum_value?(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:917 + # pkg:gem/rbi#lib/rbi/parser.rb:921 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def type_variable_definition?(node); end end @@ -1811,7 +1872,8 @@ class RBI::Printer < ::RBI::Visitor def print_locs; end # pkg:gem/rbi#lib/rbi/printer.rb:13 - def print_locs=(_arg0); end + sig { params(print_locs: T::Boolean).returns(T::Boolean) } + def print_locs=(print_locs); end # Print a string with indentation and `\n` at the end. # @@ -1845,41 +1907,41 @@ class RBI::Printer < ::RBI::Visitor private - # pkg:gem/rbi#lib/rbi/printer.rb:708 + # pkg:gem/rbi#lib/rbi/printer.rb:714 sig { params(node: ::RBI::Node).returns(T::Boolean) } def oneline?(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:676 + # pkg:gem/rbi#lib/rbi/printer.rb:682 sig { params(node: ::RBI::Node).void } def print_blank_line_before(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:686 + # pkg:gem/rbi#lib/rbi/printer.rb:692 sig { params(node: ::RBI::Node).void } def print_loc(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:692 + # pkg:gem/rbi#lib/rbi/printer.rb:698 sig { params(node: ::RBI::Param, last: T::Boolean).void } def print_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/printer.rb:767 + # pkg:gem/rbi#lib/rbi/printer.rb:773 sig { params(node: ::RBI::Sig).void } def print_sig_as_block(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:737 + # pkg:gem/rbi#lib/rbi/printer.rb:743 sig { params(node: ::RBI::Sig).void } def print_sig_as_line(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:700 + # pkg:gem/rbi#lib/rbi/printer.rb:706 sig { params(node: ::RBI::SigParam, last: T::Boolean).void } def print_sig_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/printer.rb:837 + # pkg:gem/rbi#lib/rbi/printer.rb:843 sig { params(node: ::RBI::Sig).returns(T::Array[::String]) } def sig_modifiers(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:487 + # pkg:gem/rbi#lib/rbi/printer.rb:493 sig { override.params(node: ::RBI::Arg).void } def visit_arg(node); end @@ -1931,7 +1993,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:652 + # pkg:gem/rbi#lib/rbi/printer.rb:658 sig { override.params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end @@ -1943,31 +2005,37 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:419 + # pkg:gem/rbi#lib/rbi/printer.rb:425 sig { override.params(node: ::RBI::Extend).void } def visit_extend(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:621 + # pkg:gem/rbi#lib/rbi/printer.rb:413 + sig { override.params(node: ::RBI::ForwardingParam).void } + def visit_forwarding_param(node); end + + # @override + # + # pkg:gem/rbi#lib/rbi/printer.rb:627 sig { override.params(node: ::RBI::Group).void } def visit_group(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:605 + # pkg:gem/rbi#lib/rbi/printer.rb:611 sig { override.params(node: ::RBI::Helper).void } def visit_helper(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:413 + # pkg:gem/rbi#lib/rbi/printer.rb:419 sig { override.params(node: ::RBI::Include).void } def visit_include(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:493 + # pkg:gem/rbi#lib/rbi/printer.rb:499 sig { override.params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end @@ -1997,11 +2065,11 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:615 + # pkg:gem/rbi#lib/rbi/printer.rb:621 sig { override.params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:424 + # pkg:gem/rbi#lib/rbi/printer.rb:430 sig { params(node: ::RBI::Mixin).void } def visit_mixin(node); end @@ -2025,19 +2093,19 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:454 + # pkg:gem/rbi#lib/rbi/printer.rb:460 sig { override.params(node: ::RBI::Private).void } def visit_private(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:448 + # pkg:gem/rbi#lib/rbi/printer.rb:454 sig { override.params(node: ::RBI::Protected).void } def visit_protected(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:442 + # pkg:gem/rbi#lib/rbi/printer.rb:448 sig { override.params(node: ::RBI::Public).void } def visit_public(node); end @@ -2055,7 +2123,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:642 + # pkg:gem/rbi#lib/rbi/printer.rb:648 sig { override.params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end @@ -2075,7 +2143,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:662 + # pkg:gem/rbi#lib/rbi/printer.rb:668 sig { override.params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end @@ -2085,19 +2153,19 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:469 + # pkg:gem/rbi#lib/rbi/printer.rb:475 sig { override.params(node: ::RBI::Send).void } def visit_send(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:501 + # pkg:gem/rbi#lib/rbi/printer.rb:507 sig { override.params(node: ::RBI::Sig).void } def visit_sig(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:522 + # pkg:gem/rbi#lib/rbi/printer.rb:528 sig { override.params(node: ::RBI::SigParam).void } def visit_sig_param(node); end @@ -2113,25 +2181,25 @@ class RBI::Printer < ::RBI::Visitor sig { override.params(node: ::RBI::Struct).void } def visit_struct(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:547 + # pkg:gem/rbi#lib/rbi/printer.rb:553 sig { params(node: ::RBI::TStructField).void } def visit_t_struct_field(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:566 + # pkg:gem/rbi#lib/rbi/printer.rb:572 sig { override.params(node: ::RBI::TEnum).void } def visit_tenum(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:572 + # pkg:gem/rbi#lib/rbi/printer.rb:578 sig { override.params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:585 + # pkg:gem/rbi#lib/rbi/printer.rb:591 sig { override.params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end @@ -2143,40 +2211,40 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:530 + # pkg:gem/rbi#lib/rbi/printer.rb:536 sig { override.params(node: ::RBI::TStruct).void } def visit_tstruct(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:536 + # pkg:gem/rbi#lib/rbi/printer.rb:542 sig { override.params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:542 + # pkg:gem/rbi#lib/rbi/printer.rb:548 sig { override.params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:595 + # pkg:gem/rbi#lib/rbi/printer.rb:601 sig { override.params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:459 + # pkg:gem/rbi#lib/rbi/printer.rb:465 sig { params(node: ::RBI::Visibility).void } def visit_visibility(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:628 + # pkg:gem/rbi#lib/rbi/printer.rb:634 sig { override.params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end end -# pkg:gem/rbi#lib/rbi/printer.rb:834 +# pkg:gem/rbi#lib/rbi/printer.rb:840 RBI::Printer::EMPTY_MODIFIERS = T.let(T.unsafe(nil), Array) # pkg:gem/rbi#lib/rbi/printer.rb:10 @@ -2190,9 +2258,9 @@ RBI::Printer::MAX_CACHED_INDENT = T.let(T.unsafe(nil), Integer) # pkg:gem/rbi#lib/rbi/printer.rb:5 class RBI::PrinterError < ::RBI::Error; end -# pkg:gem/rbi#lib/rbi/model.rb:970 +# pkg:gem/rbi#lib/rbi/model.rb:1007 class RBI::Private < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:972 + # pkg:gem/rbi#lib/rbi/model.rb:1009 sig do params( loc: T.nilable(::RBI::Loc), @@ -2203,9 +2271,9 @@ class RBI::Private < ::RBI::Visibility def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:962 +# pkg:gem/rbi#lib/rbi/model.rb:999 class RBI::Protected < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:964 + # pkg:gem/rbi#lib/rbi/model.rb:1001 sig do params( loc: T.nilable(::RBI::Loc), @@ -2216,9 +2284,9 @@ class RBI::Protected < ::RBI::Visibility def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:951 +# pkg:gem/rbi#lib/rbi/model.rb:988 class RBI::Public < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:953 + # pkg:gem/rbi#lib/rbi/model.rb:990 sig do params( loc: T.nilable(::RBI::Loc), @@ -2231,7 +2299,7 @@ end # Shared default instance to avoid allocating a new Public on every Method/Attr creation. # -# pkg:gem/rbi#lib/rbi/model.rb:959 +# pkg:gem/rbi#lib/rbi/model.rb:996 RBI::Public::DEFAULT = T.let(T.unsafe(nil), RBI::Public) # pkg:gem/rbi#lib/rbi/rbs/method_type_translator.rb:5 @@ -2412,7 +2480,8 @@ class RBI::RBSPrinter < ::RBI::Visitor def positional_names; end # pkg:gem/rbi#lib/rbi/rbs_printer.rb:18 - def positional_names=(_arg0); end + sig { params(positional_names: T::Boolean).returns(T::Boolean) } + def positional_names=(positional_names); end # pkg:gem/rbi#lib/rbi/rbs_printer.rb:12 sig { returns(T.nilable(::RBI::Node)) } @@ -2433,7 +2502,8 @@ class RBI::RBSPrinter < ::RBI::Visitor def print_locs; end # pkg:gem/rbi#lib/rbi/rbs_printer.rb:9 - def print_locs=(_arg0); end + sig { params(print_locs: T::Boolean).returns(T::Boolean) } + def print_locs=(print_locs); end # pkg:gem/rbi#lib/rbi/rbs_printer.rb:409 sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void } @@ -2473,7 +2543,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:662 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:668 sig { override.params(node: ::RBI::Arg).void } def visit_arg(node); end @@ -2525,7 +2595,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:798 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:804 sig { override.params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end @@ -2537,7 +2607,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:606 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:612 sig { override.params(node: ::RBI::Extend).void } def visit_extend(node); end @@ -2549,25 +2619,31 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:771 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:600 + sig { override.params(node: ::RBI::ForwardingParam).void } + def visit_forwarding_param(node); end + + # @override + # + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:777 sig { override.params(node: ::RBI::Group).void } def visit_group(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:759 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:765 sig { override.params(node: ::RBI::Helper).void } def visit_helper(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:600 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:606 sig { override.params(node: ::RBI::Include).void } def visit_include(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:668 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:674 sig { override.params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end @@ -2597,11 +2673,11 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:765 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:771 sig { override.params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:611 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:617 sig { params(node: ::RBI::Mixin).void } def visit_mixin(node); end @@ -2625,19 +2701,19 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:641 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:647 sig { override.params(node: ::RBI::Private).void } def visit_private(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:635 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:641 sig { override.params(node: ::RBI::Protected).void } def visit_protected(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:629 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:635 sig { override.params(node: ::RBI::Public).void } def visit_public(node); end @@ -2649,7 +2725,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:792 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:798 sig { override.params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end @@ -2669,7 +2745,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:808 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:814 sig { override.params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end @@ -2679,7 +2755,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:656 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:662 sig { override.params(node: ::RBI::Send).void } def visit_send(node); end @@ -2705,19 +2781,19 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:725 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:731 sig { override.params(node: ::RBI::TEnum).void } def visit_tenum(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:731 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:737 sig { override.params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:737 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:743 sig { override.params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end @@ -2729,41 +2805,41 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:674 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:680 sig { override.params(node: ::RBI::TStruct).void } def visit_tstruct(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:709 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:715 sig { override.params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:717 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:723 sig { override.params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:753 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:759 sig { override.params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:646 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:652 sig { params(node: ::RBI::Visibility).void } def visit_visibility(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:778 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:784 sig { override.params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end private - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:908 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:914 sig { params(node: ::RBI::Node).returns(T::Boolean) } def oneline?(node); end @@ -2771,31 +2847,31 @@ class RBI::RBSPrinter < ::RBI::Visitor # # Returns `nil` is the string is not a `T.let`. # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:942 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:948 sig { params(code: T.nilable(::String)).returns(T.nilable(::String)) } def parse_t_let(code); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:930 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:936 sig { params(type: T.any(::RBI::Type, ::String)).returns(::RBI::Type) } def parse_type(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:824 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:830 sig { params(node: ::RBI::Node).void } def print_blank_line_before(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:843 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:849 sig { params(node: ::RBI::Node).void } def print_loc(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:892 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:898 sig { params(node: ::RBI::Param, last: T::Boolean).void } def print_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:849 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:855 sig { params(sig_param: ::RBI::SigParam, method_param: ::RBI::Param).void } def print_sig_param(sig_param, method_param); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:900 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:906 sig { params(node: ::RBI::SigParam, last: T::Boolean).void } def print_sig_param_comment_leading_space(node, last:); end end @@ -2806,9 +2882,9 @@ class RBI::RBSPrinter::Error < ::RBI::Error; end # pkg:gem/rbi#lib/rbi/model.rb:5 class RBI::ReplaceNodeError < ::RBI::Error; end -# pkg:gem/rbi#lib/rbi/model.rb:630 +# pkg:gem/rbi#lib/rbi/model.rb:635 class RBI::ReqParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:636 + # pkg:gem/rbi#lib/rbi/model.rb:641 sig do params( name: ::String, @@ -2819,34 +2895,34 @@ class RBI::ReqParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:655 + # pkg:gem/rbi#lib/rbi/model.rb:660 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:650 + # pkg:gem/rbi#lib/rbi/model.rb:655 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:633 + # pkg:gem/rbi#lib/rbi/model.rb:638 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:644 + # pkg:gem/rbi#lib/rbi/model.rb:649 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:1412 +# pkg:gem/rbi#lib/rbi/model.rb:1449 class RBI::RequiresAncestor < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1417 + # pkg:gem/rbi#lib/rbi/model.rb:1454 sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end @@ -2856,20 +2932,20 @@ class RBI::RequiresAncestor < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1414 + # pkg:gem/rbi#lib/rbi/model.rb:1451 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1424 + # pkg:gem/rbi#lib/rbi/model.rb:1461 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:694 +# pkg:gem/rbi#lib/rbi/model.rb:699 class RBI::RestParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:700 + # pkg:gem/rbi#lib/rbi/model.rb:705 sig do params( name: T.nilable(::String), @@ -2880,25 +2956,25 @@ class RBI::RestParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:719 + # pkg:gem/rbi#lib/rbi/model.rb:724 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:714 + # pkg:gem/rbi#lib/rbi/model.rb:719 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:697 + # pkg:gem/rbi#lib/rbi/model.rb:702 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:708 + # pkg:gem/rbi#lib/rbi/model.rb:713 sig { override.returns(::String) } def to_s; end end @@ -2928,7 +3004,7 @@ class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor sig { params(method: ::RBI::Method).void } def add_method_sig(method); end - # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:71 + # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:74 sig { params(node: ::RBI::NodeWithComments).void } def add_todo_comment(node); end end @@ -3579,7 +3655,7 @@ class RBI::Scope < ::RBI::Tree # Duplicate `self` scope without its body # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:363 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:378 sig { returns(T.self_type) } def dup_empty; end @@ -3615,34 +3691,34 @@ end # end # ~~~ # -# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:665 +# pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:692 class RBI::ScopeConflict < ::RBI::Tree - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:673 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:700 sig { params(left: ::RBI::Scope, right: ::RBI::Scope, left_name: ::String, right_name: ::String).void } def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:667 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:694 sig { returns(::RBI::Scope) } def left; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:670 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:697 sig { returns(::String) } def left_name; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:667 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:694 def right; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:670 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:697 def right_name; end end # Sends # -# pkg:gem/rbi#lib/rbi/model.rb:980 +# pkg:gem/rbi#lib/rbi/model.rb:1017 class RBI::Send < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:988 + # pkg:gem/rbi#lib/rbi/model.rb:1025 sig do params( method: ::String, @@ -3654,21 +3730,21 @@ class RBI::Send < ::RBI::NodeWithComments end def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:996 + # pkg:gem/rbi#lib/rbi/model.rb:1033 sig { params(arg: ::RBI::Arg).void } def <<(arg); end - # pkg:gem/rbi#lib/rbi/model.rb:1001 + # pkg:gem/rbi#lib/rbi/model.rb:1038 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:985 + # pkg:gem/rbi#lib/rbi/model.rb:1022 sig { returns(T::Array[::RBI::Arg]) } def args; end # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:591 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:618 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -3678,20 +3754,20 @@ class RBI::Send < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:982 + # pkg:gem/rbi#lib/rbi/model.rb:1019 sig { returns(::String) } def method; end - # pkg:gem/rbi#lib/rbi/model.rb:1006 + # pkg:gem/rbi#lib/rbi/model.rb:1043 sig { returns(::String) } def to_s; end end # Sorbet's sigs # -# pkg:gem/rbi#lib/rbi/model.rb:1055 +# pkg:gem/rbi#lib/rbi/model.rb:1092 class RBI::Sig < ::RBI::NodeWithComments - # pkg:gem/rbi#lib/rbi/model.rb:1117 + # pkg:gem/rbi#lib/rbi/model.rb:1154 sig do params( params: T.nilable(T::Array[::RBI::SigParam]), @@ -3713,104 +3789,114 @@ class RBI::Sig < ::RBI::NodeWithComments end def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), bind_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1151 + # pkg:gem/rbi#lib/rbi/model.rb:1188 sig { params(param: ::RBI::SigParam).void } def <<(param); end - # pkg:gem/rbi#lib/rbi/model.rb:1161 + # pkg:gem/rbi#lib/rbi/model.rb:1198 sig { params(other: ::Object).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1156 + # pkg:gem/rbi#lib/rbi/model.rb:1193 sig { params(name: ::String, type: T.any(::RBI::Type, ::String)).void } def add_param(name, type); end - # pkg:gem/rbi#lib/rbi/model.rb:1080 + # pkg:gem/rbi#lib/rbi/model.rb:1117 sig { returns(T::Boolean) } def allow_incompatible_override; end - # pkg:gem/rbi#lib/rbi/model.rb:1080 - def allow_incompatible_override=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1117 + sig { params(allow_incompatible_override: T::Boolean).returns(T::Boolean) } + def allow_incompatible_override=(allow_incompatible_override); end - # pkg:gem/rbi#lib/rbi/model.rb:1083 + # pkg:gem/rbi#lib/rbi/model.rb:1120 sig { returns(T::Boolean) } def allow_incompatible_override_visibility; end - # pkg:gem/rbi#lib/rbi/model.rb:1083 - def allow_incompatible_override_visibility=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1120 + sig { params(allow_incompatible_override_visibility: T::Boolean).returns(T::Boolean) } + def allow_incompatible_override_visibility=(allow_incompatible_override_visibility); end - # pkg:gem/rbi#lib/rbi/model.rb:1065 + # pkg:gem/rbi#lib/rbi/model.rb:1102 sig { returns(T.nilable(T.any(::RBI::Type, ::String))) } def bind_type; end - # pkg:gem/rbi#lib/rbi/model.rb:1065 - def bind_type=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1102 + sig { params(bind_type: T.nilable(T.any(::RBI::Type, ::String))).returns(T.nilable(T.any(::RBI::Type, ::String))) } + def bind_type=(bind_type); end - # pkg:gem/rbi#lib/rbi/model.rb:1099 + # pkg:gem/rbi#lib/rbi/model.rb:1136 sig { returns(T.nilable(::Symbol)) } def checked; end - # pkg:gem/rbi#lib/rbi/model.rb:1099 - def checked=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1136 + sig { params(checked: T.nilable(::Symbol)).returns(T.nilable(::Symbol)) } + def checked=(checked); end - # pkg:gem/rbi#lib/rbi/model.rb:1068 + # pkg:gem/rbi#lib/rbi/model.rb:1105 sig { returns(T::Boolean) } def is_abstract; end - # pkg:gem/rbi#lib/rbi/model.rb:1068 - def is_abstract=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1105 + sig { params(is_abstract: T::Boolean).returns(T::Boolean) } + def is_abstract=(is_abstract); end - # pkg:gem/rbi#lib/rbi/model.rb:1077 + # pkg:gem/rbi#lib/rbi/model.rb:1114 sig { returns(T::Boolean) } def is_final; end - # pkg:gem/rbi#lib/rbi/model.rb:1077 - def is_final=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1114 + sig { params(is_final: T::Boolean).returns(T::Boolean) } + def is_final=(is_final); end - # pkg:gem/rbi#lib/rbi/model.rb:1074 + # pkg:gem/rbi#lib/rbi/model.rb:1111 sig { returns(T::Boolean) } def is_overridable; end - # pkg:gem/rbi#lib/rbi/model.rb:1074 - def is_overridable=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1111 + sig { params(is_overridable: T::Boolean).returns(T::Boolean) } + def is_overridable=(is_overridable); end - # pkg:gem/rbi#lib/rbi/model.rb:1071 + # pkg:gem/rbi#lib/rbi/model.rb:1108 sig { returns(T::Boolean) } def is_override; end - # pkg:gem/rbi#lib/rbi/model.rb:1071 - def is_override=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1108 + sig { params(is_override: T::Boolean).returns(T::Boolean) } + def is_override=(is_override); end - # pkg:gem/rbi#lib/rbi/model.rb:1057 + # pkg:gem/rbi#lib/rbi/model.rb:1094 sig { returns(T::Array[::RBI::SigParam]) } def params; end - # pkg:gem/rbi#lib/rbi/model.rb:1062 + # pkg:gem/rbi#lib/rbi/model.rb:1099 sig { returns(T.any(::RBI::Type, ::String)) } def return_type; end - # pkg:gem/rbi#lib/rbi/model.rb:1062 - def return_type=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1099 + sig { params(return_type: T.any(::RBI::Type, ::String)).returns(T.any(::RBI::Type, ::String)) } + def return_type=(return_type); end - # pkg:gem/rbi#lib/rbi/model.rb:1089 + # pkg:gem/rbi#lib/rbi/model.rb:1126 sig { returns(T::Array[::String]) } def type_params; end - # pkg:gem/rbi#lib/rbi/model.rb:1094 + # pkg:gem/rbi#lib/rbi/model.rb:1131 sig { returns(T::Boolean) } def type_params?; end - # pkg:gem/rbi#lib/rbi/model.rb:1086 + # pkg:gem/rbi#lib/rbi/model.rb:1123 sig { returns(T::Boolean) } def without_runtime; end - # pkg:gem/rbi#lib/rbi/model.rb:1086 - def without_runtime=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1123 + sig { params(without_runtime: T::Boolean).returns(T::Boolean) } + def without_runtime=(without_runtime); end end -# pkg:gem/rbi#lib/rbi/model.rb:1171 +# pkg:gem/rbi#lib/rbi/model.rb:1208 class RBI::SigParam < ::RBI::NodeWithComments - # pkg:gem/rbi#lib/rbi/model.rb:1179 + # pkg:gem/rbi#lib/rbi/model.rb:1216 sig do params( name: ::String, @@ -3822,25 +3908,25 @@ class RBI::SigParam < ::RBI::NodeWithComments end def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1199 + # pkg:gem/rbi#lib/rbi/model.rb:1236 sig { params(other: ::Object).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1194 + # pkg:gem/rbi#lib/rbi/model.rb:1231 sig { returns(T::Boolean) } def anonymous?; end - # pkg:gem/rbi#lib/rbi/model.rb:1173 + # pkg:gem/rbi#lib/rbi/model.rb:1210 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1189 + # pkg:gem/rbi#lib/rbi/model.rb:1226 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:1176 + # pkg:gem/rbi#lib/rbi/model.rb:1213 sig { returns(T.any(::RBI::Type, ::String)) } def type; end end @@ -3881,7 +3967,7 @@ class RBI::Struct < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:404 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:419 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end @@ -3896,14 +3982,16 @@ class RBI::Struct < ::RBI::Scope def keyword_init; end # pkg:gem/rbi#lib/rbi/model.rb:268 - def keyword_init=(_arg0); end + sig { params(keyword_init: T::Boolean).returns(T::Boolean) } + def keyword_init=(keyword_init); end # pkg:gem/rbi#lib/rbi/model.rb:265 sig { returns(T::Array[::Symbol]) } def members; end # pkg:gem/rbi#lib/rbi/model.rb:265 - def members=(_arg0); end + sig { params(members: T::Array[::Symbol]).returns(T::Array[::Symbol]) } + def members=(members); end # pkg:gem/rbi#lib/rbi/model.rb:262 sig { returns(::String) } @@ -3912,9 +4000,9 @@ end # Sorbet's T::Enum # -# pkg:gem/rbi#lib/rbi/model.rb:1296 +# pkg:gem/rbi#lib/rbi/model.rb:1333 class RBI::TEnum < ::RBI::Class - # pkg:gem/rbi#lib/rbi/model.rb:1298 + # pkg:gem/rbi#lib/rbi/model.rb:1335 sig do params( name: ::String, @@ -3926,9 +4014,9 @@ class RBI::TEnum < ::RBI::Class def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:1304 +# pkg:gem/rbi#lib/rbi/model.rb:1341 class RBI::TEnumBlock < ::RBI::Scope - # pkg:gem/rbi#lib/rbi/model.rb:1306 + # pkg:gem/rbi#lib/rbi/model.rb:1343 sig do params( loc: T.nilable(::RBI::Loc), @@ -3940,7 +4028,7 @@ class RBI::TEnumBlock < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1313 + # pkg:gem/rbi#lib/rbi/model.rb:1350 sig { override.returns(::String) } def fully_qualified_name; end @@ -3952,16 +4040,16 @@ class RBI::TEnumBlock < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1319 + # pkg:gem/rbi#lib/rbi/model.rb:1356 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:1324 +# pkg:gem/rbi#lib/rbi/model.rb:1361 class RBI::TEnumValue < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1329 + # pkg:gem/rbi#lib/rbi/model.rb:1366 sig do params( name: ::String, @@ -3972,7 +4060,7 @@ class RBI::TEnumValue < ::RBI::NodeWithComments end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1336 + # pkg:gem/rbi#lib/rbi/model.rb:1373 sig { returns(::String) } def fully_qualified_name; end @@ -3982,22 +4070,22 @@ class RBI::TEnumValue < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1326 + # pkg:gem/rbi#lib/rbi/model.rb:1363 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1342 + # pkg:gem/rbi#lib/rbi/model.rb:1379 sig { override.returns(::String) } def to_s; end end # Sorbet's T::Struct # -# pkg:gem/rbi#lib/rbi/model.rb:1208 +# pkg:gem/rbi#lib/rbi/model.rb:1245 class RBI::TStruct < ::RBI::Class - # pkg:gem/rbi#lib/rbi/model.rb:1210 + # pkg:gem/rbi#lib/rbi/model.rb:1247 sig do params( name: ::String, @@ -4009,11 +4097,11 @@ class RBI::TStruct < ::RBI::Class def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:1240 +# pkg:gem/rbi#lib/rbi/model.rb:1277 class RBI::TStructConst < ::RBI::TStructField include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1248 + # pkg:gem/rbi#lib/rbi/model.rb:1285 sig do params( name: ::String, @@ -4028,13 +4116,13 @@ class RBI::TStructConst < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:607 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:634 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1255 + # pkg:gem/rbi#lib/rbi/model.rb:1292 sig { override.returns(T::Array[::String]) } def fully_qualified_names; end @@ -4046,18 +4134,18 @@ class RBI::TStructConst < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1262 + # pkg:gem/rbi#lib/rbi/model.rb:1299 sig { override.returns(::String) } def to_s; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:1217 +# pkg:gem/rbi#lib/rbi/model.rb:1254 class RBI::TStructField < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:1228 + # pkg:gem/rbi#lib/rbi/model.rb:1265 sig do params( name: ::String, @@ -4071,40 +4159,42 @@ class RBI::TStructField < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:599 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:626 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1225 + # pkg:gem/rbi#lib/rbi/model.rb:1262 sig { returns(T.nilable(::String)) } def default; end - # pkg:gem/rbi#lib/rbi/model.rb:1225 - def default=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1262 + sig { params(default: T.nilable(::String)).returns(T.nilable(::String)) } + def default=(default); end # @abstract # - # pkg:gem/rbi#lib/rbi/model.rb:1237 + # pkg:gem/rbi#lib/rbi/model.rb:1274 sig { abstract.returns(T::Array[::String]) } def fully_qualified_names; end - # pkg:gem/rbi#lib/rbi/model.rb:1219 + # pkg:gem/rbi#lib/rbi/model.rb:1256 sig { returns(::String) } def name; end - # pkg:gem/rbi#lib/rbi/model.rb:1222 + # pkg:gem/rbi#lib/rbi/model.rb:1259 sig { returns(T.any(::RBI::Type, ::String)) } def type; end - # pkg:gem/rbi#lib/rbi/model.rb:1222 - def type=(_arg0); end + # pkg:gem/rbi#lib/rbi/model.rb:1259 + sig { params(type: T.any(::RBI::Type, ::String)).returns(T.any(::RBI::Type, ::String)) } + def type=(type); end end -# pkg:gem/rbi#lib/rbi/model.rb:1267 +# pkg:gem/rbi#lib/rbi/model.rb:1304 class RBI::TStructProp < ::RBI::TStructField include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1275 + # pkg:gem/rbi#lib/rbi/model.rb:1312 sig do params( name: ::String, @@ -4119,13 +4209,13 @@ class RBI::TStructProp < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:615 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:642 sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1282 + # pkg:gem/rbi#lib/rbi/model.rb:1319 sig { override.returns(T::Array[::String]) } def fully_qualified_names; end @@ -4137,7 +4227,7 @@ class RBI::TStructProp < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1289 + # pkg:gem/rbi#lib/rbi/model.rb:1326 sig { override.returns(::String) } def to_s; end end @@ -4158,7 +4248,7 @@ class RBI::Tree < ::RBI::NodeWithComments sig { params(node: ::RBI::Node).void } def <<(node); end - # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:79 + # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:82 sig { params(with_todo_comment: T::Boolean).void } def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end @@ -4194,7 +4284,7 @@ class RBI::Tree < ::RBI::NodeWithComments sig { returns(::RBI::Index) } def index; end - # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:336 + # pkg:gem/rbi#lib/rbi/rewriters/merge_trees.rb:351 sig do params( other: ::RBI::Tree, @@ -4310,7 +4400,7 @@ class RBI::Type sig { abstract.returns(::RBI::Type) } def normalize; end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1248 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1254 sig { returns(::String) } def rbs_string; end @@ -5368,11 +5458,11 @@ class RBI::Type::Void < ::RBI::Type def to_rbi; end end -# pkg:gem/rbi#lib/rbi/model.rb:1367 +# pkg:gem/rbi#lib/rbi/model.rb:1404 class RBI::TypeMember < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1372 + # pkg:gem/rbi#lib/rbi/model.rb:1409 sig do params( name: ::String, @@ -5384,7 +5474,7 @@ class RBI::TypeMember < ::RBI::NodeWithComments end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1380 + # pkg:gem/rbi#lib/rbi/model.rb:1417 sig { returns(::String) } def fully_qualified_name; end @@ -5394,113 +5484,113 @@ class RBI::TypeMember < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1369 + # pkg:gem/rbi#lib/rbi/model.rb:1406 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1388 + # pkg:gem/rbi#lib/rbi/model.rb:1425 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:1369 + # pkg:gem/rbi#lib/rbi/model.rb:1406 def value; end end -# pkg:gem/rbi#lib/rbi/rbs_printer.rb:963 +# pkg:gem/rbi#lib/rbi/rbs_printer.rb:969 class RBI::TypePrinter - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:968 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:974 sig { params(max_line_length: T.nilable(::Integer)).void } def initialize(max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:965 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:971 sig { returns(::String) } def string; end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:974 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:980 sig { params(node: ::RBI::Type).void } def visit(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1099 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1105 sig { params(type: ::RBI::Type::All).void } def visit_all(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1109 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1115 sig { params(type: ::RBI::Type::Any).void } def visit_any(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1041 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1047 sig { params(type: ::RBI::Type::Anything).void } def visit_anything(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1066 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1072 sig { params(type: ::RBI::Type::AttachedClass).void } def visit_attached_class(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1025 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1031 sig { params(type: ::RBI::Type::Boolean).void } def visit_boolean(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1176 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1182 sig { params(type: ::RBI::Type::Class).void } def visit_class(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1084 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1090 sig { params(type: ::RBI::Type::ClassOf).void } def visit_class_of(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1030 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1036 sig { params(type: ::RBI::Type::Generic).void } def visit_generic(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1183 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1189 sig { params(type: ::RBI::Type::Module).void } def visit_module(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1071 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1077 sig { params(type: ::RBI::Type::Nilable).void } def visit_nilable(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1051 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1057 sig { params(type: ::RBI::Type::NoReturn).void } def visit_no_return(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1149 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1155 sig { params(type: ::RBI::Type::Proc).void } def visit_proc(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1061 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1067 sig { params(type: ::RBI::Type::SelfType).void } def visit_self_type(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1129 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1135 sig { params(type: ::RBI::Type::Shape).void } def visit_shape(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1020 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1026 sig { params(type: ::RBI::Type::Simple).void } def visit_simple(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1119 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1125 sig { params(type: ::RBI::Type::Tuple).void } def visit_tuple(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1171 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1177 sig { params(type: ::RBI::Type::TypeParameter).void } def visit_type_parameter(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1056 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1062 sig { params(type: ::RBI::Type::Untyped).void } def visit_untyped(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1046 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1052 sig { params(type: ::RBI::Type::Void).void } def visit_void(type); end private - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1192 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1198 sig { params(type_name: ::String).returns(::String) } def translate_t_type(type_name); end end @@ -5536,31 +5626,31 @@ RBI::VERSION = T.let(T.unsafe(nil), String) # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:918 +# pkg:gem/rbi#lib/rbi/model.rb:955 class RBI::Visibility < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:923 + # pkg:gem/rbi#lib/rbi/model.rb:960 sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:929 + # pkg:gem/rbi#lib/rbi/model.rb:966 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:946 + # pkg:gem/rbi#lib/rbi/model.rb:983 sig { returns(T::Boolean) } def private?; end - # pkg:gem/rbi#lib/rbi/model.rb:941 + # pkg:gem/rbi#lib/rbi/model.rb:978 sig { returns(T::Boolean) } def protected?; end - # pkg:gem/rbi#lib/rbi/model.rb:936 + # pkg:gem/rbi#lib/rbi/model.rb:973 sig { returns(T::Boolean) } def public?; end - # pkg:gem/rbi#lib/rbi/model.rb:920 + # pkg:gem/rbi#lib/rbi/model.rb:957 sig { returns(::Symbol) } def visibility; end end @@ -5586,193 +5676,197 @@ class RBI::Visitor sig { params(node: T.nilable(::RBI::Node)).void } def visit(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:110 + # pkg:gem/rbi#lib/rbi/visitor.rb:112 sig { params(nodes: T::Array[::RBI::Node]).void } def visit_all(nodes); end - # pkg:gem/rbi#lib/rbi/visitor.rb:115 + # pkg:gem/rbi#lib/rbi/visitor.rb:117 sig { params(file: ::RBI::File).void } def visit_file(file); end private - # pkg:gem/rbi#lib/rbi/visitor.rb:203 + # pkg:gem/rbi#lib/rbi/visitor.rb:208 sig { params(node: ::RBI::Arg).void } def visit_arg(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:149 + # pkg:gem/rbi#lib/rbi/visitor.rb:151 sig { params(node: ::RBI::AttrAccessor).void } def visit_attr_accessor(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:152 + # pkg:gem/rbi#lib/rbi/visitor.rb:154 sig { params(node: ::RBI::AttrReader).void } def visit_attr_reader(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:155 + # pkg:gem/rbi#lib/rbi/visitor.rb:157 sig { params(node: ::RBI::AttrWriter).void } def visit_attr_writer(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:128 + # pkg:gem/rbi#lib/rbi/visitor.rb:130 sig { params(node: ::RBI::BlankLine).void } def visit_blank_line(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:182 + # pkg:gem/rbi#lib/rbi/visitor.rb:184 sig { params(node: ::RBI::BlockParam).void } def visit_block_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:134 + # pkg:gem/rbi#lib/rbi/visitor.rb:136 sig { params(node: ::RBI::Class).void } def visit_class(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:122 + # pkg:gem/rbi#lib/rbi/visitor.rb:124 sig { params(node: ::RBI::Comment).void } def visit_comment(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:251 + # pkg:gem/rbi#lib/rbi/visitor.rb:256 sig { params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:146 + # pkg:gem/rbi#lib/rbi/visitor.rb:148 sig { params(node: ::RBI::Const).void } def visit_const(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:188 + # pkg:gem/rbi#lib/rbi/visitor.rb:193 sig { params(node: ::RBI::Extend).void } def visit_extend(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:245 + # pkg:gem/rbi#lib/rbi/visitor.rb:187 + sig { params(node: ::RBI::ForwardingParam).void } + def visit_forwarding_param(node); end + + # pkg:gem/rbi#lib/rbi/visitor.rb:250 sig { params(node: ::RBI::Group).void } def visit_group(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:233 + # pkg:gem/rbi#lib/rbi/visitor.rb:238 sig { params(node: ::RBI::Helper).void } def visit_helper(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:185 + # pkg:gem/rbi#lib/rbi/visitor.rb:190 sig { params(node: ::RBI::Include).void } def visit_include(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:206 + # pkg:gem/rbi#lib/rbi/visitor.rb:211 sig { params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:173 + # pkg:gem/rbi#lib/rbi/visitor.rb:175 sig { params(node: ::RBI::KwOptParam).void } def visit_kw_opt_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:170 + # pkg:gem/rbi#lib/rbi/visitor.rb:172 sig { params(node: ::RBI::KwParam).void } def visit_kw_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:176 + # pkg:gem/rbi#lib/rbi/visitor.rb:178 sig { params(node: ::RBI::KwRestParam).void } def visit_kw_rest_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:158 + # pkg:gem/rbi#lib/rbi/visitor.rb:160 sig { params(node: ::RBI::Method).void } def visit_method(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:239 + # pkg:gem/rbi#lib/rbi/visitor.rb:244 sig { params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:131 + # pkg:gem/rbi#lib/rbi/visitor.rb:133 sig { params(node: ::RBI::Module).void } def visit_module(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:179 + # pkg:gem/rbi#lib/rbi/visitor.rb:181 sig { params(node: ::RBI::NoKwParam).void } def visit_no_kw_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:164 + # pkg:gem/rbi#lib/rbi/visitor.rb:166 sig { params(node: ::RBI::OptParam).void } def visit_opt_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:197 + # pkg:gem/rbi#lib/rbi/visitor.rb:202 sig { params(node: ::RBI::Private).void } def visit_private(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:194 + # pkg:gem/rbi#lib/rbi/visitor.rb:199 sig { params(node: ::RBI::Protected).void } def visit_protected(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:191 + # pkg:gem/rbi#lib/rbi/visitor.rb:196 sig { params(node: ::RBI::Public).void } def visit_public(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:125 + # pkg:gem/rbi#lib/rbi/visitor.rb:127 sig { params(node: ::RBI::RBSComment).void } def visit_rbs_comment(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:161 + # pkg:gem/rbi#lib/rbi/visitor.rb:163 sig { params(node: ::RBI::ReqParam).void } def visit_req_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:242 + # pkg:gem/rbi#lib/rbi/visitor.rb:247 sig { params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:167 + # pkg:gem/rbi#lib/rbi/visitor.rb:169 sig { params(node: ::RBI::RestParam).void } def visit_rest_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:254 + # pkg:gem/rbi#lib/rbi/visitor.rb:259 sig { params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:200 + # pkg:gem/rbi#lib/rbi/visitor.rb:205 sig { params(node: ::RBI::Send).void } def visit_send(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:209 + # pkg:gem/rbi#lib/rbi/visitor.rb:214 sig { params(node: ::RBI::Sig).void } def visit_sig(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:212 + # pkg:gem/rbi#lib/rbi/visitor.rb:217 sig { params(node: ::RBI::SigParam).void } def visit_sig_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:137 + # pkg:gem/rbi#lib/rbi/visitor.rb:139 sig { params(node: ::RBI::SingletonClass).void } def visit_singleton_class(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:140 + # pkg:gem/rbi#lib/rbi/visitor.rb:142 sig { params(node: ::RBI::Struct).void } def visit_struct(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:224 + # pkg:gem/rbi#lib/rbi/visitor.rb:229 sig { params(node: ::RBI::TEnum).void } def visit_tenum(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:227 + # pkg:gem/rbi#lib/rbi/visitor.rb:232 sig { params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:230 + # pkg:gem/rbi#lib/rbi/visitor.rb:235 sig { params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:143 + # pkg:gem/rbi#lib/rbi/visitor.rb:145 sig { params(node: ::RBI::Tree).void } def visit_tree(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:215 + # pkg:gem/rbi#lib/rbi/visitor.rb:220 sig { params(node: ::RBI::TStruct).void } def visit_tstruct(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:218 + # pkg:gem/rbi#lib/rbi/visitor.rb:223 sig { params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:221 + # pkg:gem/rbi#lib/rbi/visitor.rb:226 sig { params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:236 + # pkg:gem/rbi#lib/rbi/visitor.rb:241 sig { params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:248 + # pkg:gem/rbi#lib/rbi/visitor.rb:253 sig { params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end end diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.16.0.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.17.1.rbi similarity index 90% rename from sorbet/rbi/gems/rubocop-sorbet@0.16.0.rbi rename to sorbet/rbi/gems/rubocop-sorbet@0.17.1.rbi index cf0d035fc..d3c3671eb 100644 --- a/sorbet/rbi/gems/rubocop-sorbet@0.16.0.rbi +++ b/sorbet/rbi/gems/rubocop-sorbet@0.17.1.rbi @@ -20,7 +20,7 @@ end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb:5 module RuboCop::Cop::Sorbet; end -# Disallows using `.override(allow_incompatible: true)`. +# Disallows incompatible overrides in Sorbet signatures and RBS comments. # Using `allow_incompatible` suggests a violation of the Liskov # Substitution Principle, meaning that a subclass is not a valid # subtype of its superclass. This Cop prevents these design smells @@ -29,39 +29,69 @@ module RuboCop::Cop::Sorbet; end # @example # # # bad -# sig.override(allow_incompatible: true) +# sig { override(allow_incompatible: true).void } +# def foo; end +# +# # @override(allow_incompatible: true) +# #: () -> void +# def foo; end +# +# # @override(allow_incompatible: true) +# #: String +# attr_reader :foo # # # good -# sig.override +# sig { override.void } +# +# # @override +# #: () -> void +# def foo; end # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:21 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:34 class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Base - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:55 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:80 def on_block(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:73 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:64 + def on_def(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:68 + def on_defs(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:98 def on_itblock(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:72 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:97 def on_numblock(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:49 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:70 def on_send(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:41 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:56 def override?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:36 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:51 def sig?(param0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:27 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:42 def sig_dot_override?(param0 = T.unsafe(nil)); end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:102 + def check_rbs_annotations(node); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:22 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:35 RuboCop::Cop::Sorbet::AllowIncompatibleOverride::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:24 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:37 +RuboCop::Cop::Sorbet::AllowIncompatibleOverride::RBS_ALLOW_INCOMPATIBLE_OVERRIDE = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:38 +RuboCop::Cop::Sorbet::AllowIncompatibleOverride::RBS_ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array) + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:39 RuboCop::Cop::Sorbet::AllowIncompatibleOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Disallows binding the return value of `T.any`, `T.all`, `T.enum` @@ -592,31 +622,31 @@ RuboCop::Cop::Sorbet::EnforceSigilOrder::PREFERRED_ORDER = T.let(T.unsafe(nil), # * `Style`: signature style to enforce - 'sig' for sig blocks, 'rbs' for RBS comments, 'both' to allow either (default: 'sig') # * `AutocorrectStyle`: signature style to use when autocorrecting - 'sig' for sig blocks, 'rbs' for RBS comments (default: 'sig'). Only used when `Style` is 'both'. # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:29 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:30 class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::Sorbet::SignatureHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:43 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:44 def accessor?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:47 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:48 def on_def(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:51 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:52 def on_defs(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:63 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:64 def on_new_investigation; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:55 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:56 def on_send(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:59 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:60 def on_signature(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:69 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:70 def scope(node); end private @@ -627,55 +657,58 @@ class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:315 def allow_rbs?; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:149 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:153 def autocorrect_rbs_to_sigs(corrector, node, rbs_signatures); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:165 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:169 def autocorrect_sigs_to_rbs(corrector, node, sig_nodes); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:334 def autocorrect_style; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:139 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:140 def autocorrect_with_signature_type(corrector, node, type); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:78 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:79 def check_node(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:274 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:148 + def create_signature_suggestion(node, type); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:273 def in_sclass_context?(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:270 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:269 def instance_initialize?(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:248 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:247 def leftmost_send_ancestor(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:175 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:179 def normalize_runtime_sig_receivers(range, sig_nodes); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:307 def param_type_placeholder; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:285 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:284 def populate_accessor_suggestion(suggest, node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:262 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:261 def populate_method_definition_suggestion(suggest, node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:254 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:253 def populate_signature_suggestion(suggest, node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:135 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:136 def rbs_checker; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:197 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:201 def rbs_correction_range(comments); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:159 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:163 def remove_rbs(corrector, rbs_signatures); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:188 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:192 def remove_sigs(corrector, sig_nodes); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 @@ -684,25 +717,22 @@ class RuboCop::Cop::Sorbet::EnforceSignatures < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:299 def set_void_return_for_writer(suggest, method); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:131 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:132 def sig_checker; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:193 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:197 def sig_correction_range(sig_nodes); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:319 def signature_style; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:241 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:240 def translate_rbs_to_sigs(input); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:211 - def translate_signature_to_rbs(signature, node); end - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:233 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:232 def translate_sigs_to_rbs(input); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:216 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:215 def translated_signature_prefix(translated, reject_sig: T.unsafe(nil)); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:303 @@ -713,34 +743,34 @@ end # @kind is the RuboCop AST node type (:arg, :optarg, :restarg, :kwarg, # :kwoptarg, :kwrestarg, :forward_arg, :blockarg). # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 class RuboCop::Cop::Sorbet::EnforceSignatures::Param < ::Struct - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def kind; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def kind=(_); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def name; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def name=(_); end class << self - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def [](*_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def inspect; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def keyword_init?; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def members; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:40 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:41 def new(*_arg0); end end end @@ -751,6 +781,35 @@ class RuboCop::Cop::Sorbet::EnforceSignatures::RBSSignatureChecker < ::RuboCop:: def signatures(node); end end +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:380 +class RuboCop::Cop::Sorbet::EnforceSignatures::RBSSuggestion + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:383 + def initialize(indent, param_placeholder, return_placeholder); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + def accessor; end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + def accessor=(_arg0); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + def params; end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + def params=(_arg0); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:392 + def returns=(value); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:396 + def to_autocorrect; end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:418 + def rbi_params(param); end +end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:359 class RuboCop::Cop::Sorbet::EnforceSignatures::SigSignatureChecker < ::RuboCop::Cop::Sorbet::EnforceSignatures::SignatureChecker # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:362 @@ -769,32 +828,38 @@ end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:360 RuboCop::Cop::Sorbet::EnforceSignatures::SigSignatureChecker::EMPTY_SIGNATURES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:380 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:448 class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:383 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:451 def initialize(indent, param_placeholder, return_placeholder); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 + def accessor; end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 + def accessor=(_arg0); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 def params; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 def params=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 def returns; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:381 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:449 def returns=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:391 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:459 def to_autocorrect; end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:397 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:465 def generate_params; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:404 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:472 def generate_return; end end @@ -809,10 +874,10 @@ class RuboCop::Cop::Sorbet::EnforceSignatures::SignatureChecker def processed_source; end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:35 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:36 RuboCop::Cop::Sorbet::EnforceSignatures::VALID_AUTOCORRECT_STYLES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:34 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:35 RuboCop::Cop::Sorbet::EnforceSignatures::VALID_STYLES = T.let(T.unsafe(nil), Array) # Checks that there is only one Sorbet sigil in a given file @@ -1258,6 +1323,37 @@ RuboCop::Cop::Sorbet::ForbidTAnyWithNil::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_any_with_nil.rb:23 RuboCop::Cop::Sorbet::ForbidTAnyWithNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Disallows using `T.assert_type!` anywhere. +# +# @example +# +# # bad +# T.assert_type!(foo, Integer) +# +# # good +# raise unless foo.is_a?(Integer) +# +# # good +# assert_kind_of(Integer, foo) +# +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:20 +class RuboCop::Cop::Sorbet::ForbidTAssertType < ::RuboCop::Cop::Base + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:30 + def on_csend(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:27 + def on_send(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:25 + def t_assert_type?(param0 = T.unsafe(nil)); end +end + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:21 +RuboCop::Cop::Sorbet::ForbidTAssertType::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_assert_type.rb:22 +RuboCop::Cop::Sorbet::ForbidTAssertType::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Disallows using `T.bind` anywhere. # Set `AutocorrectToRBS: true` to replace supported calls with RBS inline comments. # @@ -1375,6 +1471,80 @@ RuboCop::Cop::Sorbet::ForbidTCast::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_cast.rb:24 RuboCop::Cop::Sorbet::ForbidTCast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Disallows instantiating Sorbet collection types. Instantiate the Ruby +# collection directly and declare its type separately when needed. +# +# Checks `T::Array`, `T::Hash`, `T::Set`, `T::Range`, +# `T::Enumerator`, `T::Enumerator::Lazy`, and `T::Enumerator::Chain`, +# with or without type arguments. +# +# Set `AutocorrectToRBS: true` to replace Sorbet constructors with Ruby +# constructors. RBS inline type annotations are added only to assignments. +# Assignments with an existing RBS annotation or an untranslatable type +# are not autocorrected. +# Empty Array and Hash constructors use literals unless arguments, blocks, +# or comments inside the call need to be preserved. +# +# @safety +# Autocorrection removes runtime evaluation of type arguments and changes +# constant lookup. RBS annotations require an RBS-aware type checker. +# +# @example +# # bad +# T::Array[String].new +# T::Hash[Symbol, Integer].new +# T::Set[String].new +# T::Array.new +# +# # good +# Array.new +# Hash.new +# Set.new +# T.let(Array.new, T::Array[String]) +# Set.new #: Set[String] +# +# @example AutocorrectToRBS: true +# # bad +# arr = T::Array[String].new +# items = T::Set[T.nilable(String)].new(values) +# consume(T::Array[String].new) +# +# # good +# arr = [] #: Array[String] +# items = Set.new(values) #: Set[String?] +# consume([]) +# +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:50 +class RuboCop::Cop::Sorbet::ForbidTCollectionInstantiation < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::Sorbet::RBSAssertionCorrection + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:74 + def on_csend(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:65 + def on_send(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:58 + def t_collection?(param0 = T.unsafe(nil)); end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:78 + def autocorrect_to_rbs(corrector, node, type); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:105 + def empty_collection_literal(node, type); end +end + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:54 +RuboCop::Cop::Sorbet::ForbidTCollectionInstantiation::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_collection_instantiation.rb:55 +RuboCop::Cop::Sorbet::ForbidTCollectionInstantiation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Disallow using `T::Enum`. # # @example @@ -1616,90 +1786,82 @@ RuboCop::Cop::Sorbet::ForbidTSig::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # end # end # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:62 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:63 class RuboCop::Cop::Sorbet::ForbidTStruct < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::CommentsHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:314 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:232 def on_class(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:359 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:277 def on_send(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:312 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:230 def t_props?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:307 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:225 def t_struct?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:415 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:333 def autocorrect_style; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:367 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:285 def initialize_method(indent, props); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:411 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:329 def previous_line_blank?(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:425 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:343 def rbs?; end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:71 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:72 RuboCop::Cop::Sorbet::ForbidTStruct::MSG_PROPS = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:70 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:71 RuboCop::Cop::Sorbet::ForbidTStruct::MSG_STRUCT = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:131 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:141 class RuboCop::Cop::Sorbet::ForbidTStruct::Property - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:140 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:144 def initialize(node, kind, name, type, default:, factory:, style: T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:162 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:165 def attr_accessor; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:154 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:157 def attr_sig; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:138 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:142 def default; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:138 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:142 def factory; end - # `T::Array[X]`, `T::Hash[K, V]`, and `T::Set[X]` become the RBS - # generics `Array[X]`, `Hash[K, V]`, `Set[X]`. Other const receivers - # keep their class name (custom generics). Non-const receivers return - # nil so the caller falls back to `untyped` instead of `untyped[X]`. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:295 - def generic_base(node); end - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:186 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:189 def initialize_assign; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:173 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:176 def initialize_param; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:166 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:169 def initialize_sig_param; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:138 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:142 def kind; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:138 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:142 def name; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:193 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:196 def nilable?; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:138 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:142 def node; end # A prop is optional when it declares a `default:`, a `factory:`, or @@ -1707,95 +1869,79 @@ class RuboCop::Cop::Sorbet::ForbidTStruct::Property # optional keyword parameters with `?name:`, mirroring the default # value that `initialize_param` emits. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:201 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:204 def optional?; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:210 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:213 def rbs?; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:214 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:217 def rbs_type; end - # Translate a Sorbet type expression AST node into RBS syntax. - # Handles the constructs most commonly found on `T::Struct` props: - # `T.nilable`, `T.any`, `T.all`, `T.untyped`, `T.class_of`, and - # generics like `T::Array[X]`. Any unrecognized node falls back to - # the valid RBS `untyped` rather than emitting malformed Sorbet - # syntax (e.g. `T.proc...`) into an RBS annotation. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:224 - def sorbet_type_to_rbs(node); end - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:274 - def t_const?(node); end - - # Bare class constants are valid RBS class-instance types, except - # for Sorbet's `T::Boolean` (-> `bool`) and other `T::X` constants - # which have no RBS equivalent and fall back to `untyped`. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:281 - def translate_const(node); end - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:237 - def translate_send_type(node); end - - # Maps `T.xxx(...)` type constructors to RBS. Unknown `T.xxx` sends - # become `untyped` so the annotation stays valid RBS. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:253 - def translate_t_method(method, args); end - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:205 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:208 def type; end end -# Sorbet `T::X[...]` generics that have a direct RBS equivalent. -# -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:133 -RuboCop::Cop::Sorbet::ForbidTStruct::Property::GENERIC_BASE_NAMES = T.let(T.unsafe(nil), Array) - -# Sorbet bare `T::X` constants that map to an RBS built-in. -# -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:136 -RuboCop::Cop::Sorbet::ForbidTStruct::Property::T_CONST_MAP = T.let(T.unsafe(nil), Hash) - -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:68 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:69 RuboCop::Cop::Sorbet::ForbidTStruct::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # This class walks down the class body of a T::Struct and collects all the properties that will need to be # translated into `attr_reader` and `attr_accessor` methods. # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:76 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:77 class RuboCop::Cop::Sorbet::ForbidTStruct::TStructWalker include ::RuboCop::AST::Traversal extend ::RuboCop::AST::NodePattern::Macros - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:81 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:82 def initialize(style = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:89 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:90 def extend_t_sig?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:79 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:80 def extend_t_sig_node; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:79 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:80 def has_extend_t_sig; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:98 + # Override AST::Traversal's callbacks to stop at nested scopes, so their properties and `extend T::Sig` stay + # out of this class. + # RuboCop's separate traversal still visits nested structs and creates a fresh walker for each. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:102 + def on_class(_node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:105 + def on_def(_node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:106 + def on_defs(_node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:103 + def on_module(_node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:104 + def on_sclass(_node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:108 def on_send(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:79 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:80 def props; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:94 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:95 def t_struct_prop?(param0 = T.unsafe(nil)); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:73 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_struct.rb:74 RuboCop::Cop::Sorbet::ForbidTStruct::VALID_AUTOCORRECT_STYLES = T.let(T.unsafe(nil), Array) # Disallows using `T.type_alias` anywhere. +# Set `AutocorrectToRBS: true` to replace standalone constant assignments with RBS type aliases. +# Autocorrection is unsafe because it removes the Ruby constant. References to the +# constant must be migrated separately to the lowercase RBS alias name. +# Declarations containing RuboCop directives are not autocorrected. # # @example # @@ -1805,22 +1951,35 @@ RuboCop::Cop::Sorbet::ForbidTStruct::VALID_AUTOCORRECT_STYLES = T.let(T.unsafe(n # # good # #: type string_or_integer = Integer | String # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:17 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:22 class RuboCop::Cop::Sorbet::ForbidTTypeAlias < ::RuboCop::Cop::Base - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:23 + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::Sorbet::RBSAssertionCorrection + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:31 def on_block(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:27 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:37 def on_itblock(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:26 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:36 def on_numblock(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:21 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:29 def t_type_alias?(param0 = T.unsafe(nil)); end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:41 + def autocorrect_type_alias(corrector, node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:69 + def standalone_alias?(assignment); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:18 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:26 RuboCop::Cop::Sorbet::ForbidTTypeAlias::MSG = T.let(T.unsafe(nil), String) # Disallows using `T.unsafe` anywhere. @@ -2412,6 +2571,11 @@ RuboCop::Cop::Sorbet::RedundantTLet::MSG_CONSTRUCTOR = T.let(T.unsafe(nil), Stri # flagged when that inferred type matches the annotation exactly, to # avoid silently widening (e.g. `["a", nil]` infers a nilable element). # +# An array annotation whose direct element type is a fixed-size tuple is +# preserved. Removing `T::Array[[...]]` or `Array[[...]]` can widen each +# tuple into an array with a union element type and lose its positional +# types. +# # Hashes are excluded: Sorbet infers hash literals as `T.untyped`, so the # annotation is required. # @@ -2449,6 +2613,10 @@ RuboCop::Cop::Sorbet::RedundantTLet::MSG_CONSTRUCTOR = T.let(T.unsafe(nil), Stri # # good — unfrozen array whose annotation is wider than the inferred type # NAMES = T.let(["alice", "bob"], T::Array[T.nilable(String)]) # +# # good — the tuple element type is not inferred from the nested literals +# BUCKETS = T.let([[1, "one"]].freeze, T::Array[[Integer, String]]) +# RBS_BUCKETS = [[1, "one"]].freeze #: Array[[Integer, String]] +# # # good — type is not the literal's own class # value = T.let("hello", T.nilable(String)) # @@ -2458,7 +2626,7 @@ RuboCop::Cop::Sorbet::RedundantTLet::MSG_CONSTRUCTOR = T.let(T.unsafe(nil), Stri # # good — local variables may need T.let so Sorbet allows reassignment # count = T.let(0, Integer) # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:71 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:80 class RuboCop::Cop::Sorbet::RedundantTLetForLiteral < ::RuboCop::Cop::Base include ::RuboCop::Cop::Sorbet::ConstantScope include ::RuboCop::Cop::Sorbet::TargetSorbetVersion @@ -2466,18 +2634,18 @@ class RuboCop::Cop::Sorbet::RedundantTLetForLiteral < ::RuboCop::Cop::Base extend ::RuboCop::Cop::Sorbet::TargetSorbetVersion::ClassMethods extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:125 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:134 def on_casgn(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:121 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:130 def t_let_with_array?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:116 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:125 def t_let_with_literal_and_class?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:171 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:180 def check_rbs_annotation(node); end # An array literal is inferable only when every element is one of the @@ -2485,7 +2653,7 @@ class RuboCop::Cop::Sorbet::RedundantTLetForLiteral < ::RuboCop::Cop::Base # inferable array). Empty arrays are excluded: they infer as # `T::Array[T.untyped]` and so still need the annotation. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:216 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:230 def inferable_array?(node); end # Returns the underlying literal when its inference is supported by the @@ -2493,44 +2661,50 @@ class RuboCop::Cop::Sorbet::RedundantTLetForLiteral < ::RuboCop::Cop::Base # returns its receiver only for regexps, whose inference survives # `.freeze` on supported targets. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:156 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:165 def inferable_literal_node(value_node); end # The type Sorbet infers for an unfrozen array literal, or nil when the # element types are not uniform enough to render deterministically # (mixed classes, booleans, nils and nested arrays are left alone). # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:248 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:267 def inferred_array_type(node); end # Strips whitespace and any trailing comma before a closing delimiter, # so a multi-line annotation (`T::Array[\n String,\n]`) still compares # equal to the rendered inferred type. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:258 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:277 def normalize(source); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:222 + def rbs_array_type_with_tuple_element?(type); end + # Returns whether Sorbet's inferred array type makes the annotation # redundant. A frozen `[:a].freeze` infers as a tuple compatible with # any `T::Array[...]`; an unfrozen `[:a]` must infer exactly the # annotated type, such as `T::Array[Symbol]`. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:233 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:247 def redundant_array_annotation?(array_node, type_node, frozen:); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:205 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:214 def redundant_rbs_array_annotation?(array_node, type, frozen:); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:164 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:173 def register_offense(node, value_node, type); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:198 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:207 def register_rbs_offense(node, comment, type); end # `T::Array[...]` (with or without a leading `::`) # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:240 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:259 def t_array_type?(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:254 + def t_array_type_with_tuple_element?(node); end end # Element node types allowed inside an inferable array literal: the @@ -2539,22 +2713,22 @@ end # they are excluded. Interpolated strings/symbols (`dstr`/`dsym`) infer # as `String`/`Symbol`, the same as their plain literal forms. # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:102 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:111 RuboCop::Cop::Sorbet::RedundantTLetForLiteral::ARRAY_ELEMENT_TYPES = T.let(T.unsafe(nil), Array) # Element node types whose inferred class is unambiguous, used to derive # the element type of an unfrozen array literal. # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:106 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:115 RuboCop::Cop::Sorbet::RedundantTLetForLiteral::ELEMENT_TYPE_TO_CLASS = T.let(T.unsafe(nil), Hash) # Simple literal node types Sorbet infers, mapped to the class name. # Interpolated strings/symbols (`dstr`/`dsym`) infer as `String`/`Symbol`. # -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:87 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:96 RuboCop::Cop::Sorbet::RedundantTLetForLiteral::LITERAL_TYPE_TO_CLASS = T.let(T.unsafe(nil), Hash) -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:83 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb:92 RuboCop::Cop::Sorbet::RedundantTLetForLiteral::MSG = T.let(T.unsafe(nil), String) # Checks for the use of Ruby Refinements library. Refinements add @@ -2983,7 +3157,7 @@ module RuboCop::Cop::Sorbet::TEnum extend ::RuboCop::AST::NodePattern::Macros # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_enum.rb:9 - def initialize(*_arg0); end + def initialize(*); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_enum.rb:23 def after_class(node); end @@ -3352,25 +3526,33 @@ end # No Cop::Base state is required. # # `rbs_signatures_before` returns `Signature` objects that encapsulate one -# RBS overload each. `rbs_annotation_after` returns the trailing RBS -# annotation attached to an expression and its comment node. +# RBS overload each. `rbs_annotations_before` returns the attached `# @` +# comments. `rbs_annotation_after` returns the trailing RBS annotation +# attached to an expression and its comment node. # -# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:16 +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:19 module RuboCop::Sorbet::RBSParser class << self # The trailing RBS annotation attached to `node`, as `[comment, text]`. # The comment must follow the expression on its final line with only # horizontal whitespace between them. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:36 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:51 def rbs_annotation_after(processed_source, node); end + # The Sorbet `# @` annotation comments attached to `node`, in source + # order. Other comments in the contiguous block, including the RBS + # signature itself, are omitted. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:41 + def rbs_annotations_before(processed_source, node); end + # The RBS signatures attached to `node`, one `Signature` per overload. # Climbs `private`/`public`/other send wrappers, collects the contiguous # comment block above the unwrapped node, and groups the RBS comments. # A signature separated from the method by a blank line is not attached. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:27 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:32 def rbs_signatures_before(processed_source, node); end private @@ -3378,95 +3560,68 @@ module RuboCop::Sorbet::RBSParser # Comments forming a contiguous block immediately above `node`, in source # order. A blank line or non-comment sibling breaks the run. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:72 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:87 def comments_above(processed_source, node); end # Group already-collected comments into RBS signatures. A `#:` line begins # a new overload; subsequent `#|` lines continue it. Non-RBS comments are # skipped. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:57 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:72 def rbs_signature_groups(comments); end end end +# `# @` begins a Sorbet method annotation used alongside RBS signatures. +# +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:25 +RuboCop::Sorbet::RBSParser::RBS_ANNOTATION_PREFIX = T.let(T.unsafe(nil), Regexp) + # `#|` continues the preceding `#:` signature (e.g. multiline params/returns). # -# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:20 +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:23 RuboCop::Sorbet::RBSParser::RBS_CONTINUATION_PREFIX = T.let(T.unsafe(nil), Regexp) # `#:` begins an RBS signature (each repeated `#:` line is a new overload). # -# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:18 +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:21 RuboCop::Sorbet::RBSParser::RBS_SIGNATURE_PREFIX = T.let(T.unsafe(nil), Regexp) # One RBS signature (a `#:` line plus any `#|` continuation lines). # Encapsulates the parsed structure so callers query the signature rather # than re-parsing comments through the module. # -# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:94 +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:109 class RuboCop::Sorbet::RBSParser::Signature - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:97 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:112 def initialize(processed_source, comments); end - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:95 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:110 def comments; end - # The return type expression as a string (e.g. `"String"`, `"void"`, - # `"^(Integer) -> void"`, `"Integer | String"`), or nil if the - # signature has no return arrow or an empty return. + # The return type expression as a string, or nil if parsing fails. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:105 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:118 def return_type; end - # `[highlight_range, replace_range]` covering the return type - # expression, or nil if there is no return type. `highlight_range` - # covers the first token (which may span `#|` lines); `replace_range` - # covers the entire return expression. + # `[highlight_range, replace_range]` covering the return type, or nil + # if parsing fails or the return type has no source location. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:113 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:124 def return_type_range; end # True if the signature declares a `void` return type. # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:120 + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:141 def void?; end private - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:130 - def compute; end - - # Index of the method return arrow: the first `->` at the top level, - # i.e. outside parameter/block/proc delimiters. A proc return type such - # as `^(Integer) -> void` has its own nested arrow that must not be - # mistaken for the method arrow. - # # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:151 - def method_arrow_index(joined); end + def parsed_method_type; end - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:126 - def parsed; end - - # Map a position within the joined signature back to the originating - # comment and build a source range covering `length` characters. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:168 - def range_for_token(segments, token_start, length); end - - # Source position at the end of the group's last non-blank signature - # content; the return type expression runs to here. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:186 - def return_end_pos(segments); end - - # Strip the leading `#:`/`#|` marker and surrounding whitespace, - # returning `[content, prefix_length]`. `prefix_length` is the number - # of characters consumed from the original text, for mapping - # joined-content positions back to source offsets. - # - # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:198 - def strip_rbs_prefix(text); end + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:147 + def return_type_node; end end # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/version.rb:5 diff --git a/sorbet/rbi/gems/rubocop@1.91.0.rbi b/sorbet/rbi/gems/rubocop@1.92.0.rbi similarity index 93% rename from sorbet/rbi/gems/rubocop@1.91.0.rbi rename to sorbet/rbi/gems/rubocop@1.92.0.rbi index e7c1ca879..11442c3df 100644 --- a/sorbet/rbi/gems/rubocop@1.91.0.rbi +++ b/sorbet/rbi/gems/rubocop@1.92.0.rbi @@ -96,13 +96,13 @@ end # # pkg:gem/rubocop#lib/rubocop/cli.rb:8 class RuboCop::CLI - # pkg:gem/rubocop#lib/rubocop/cli.rb:24 + # pkg:gem/rubocop#lib/rubocop/cli.rb:25 def initialize; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:22 + # pkg:gem/rubocop#lib/rubocop/cli.rb:23 def config_store; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:22 + # pkg:gem/rubocop#lib/rubocop/cli.rb:23 def options; end # @api public @@ -114,59 +114,59 @@ class RuboCop::CLI # @param args [Array] command line arguments # @return [Integer] UNIX exit code # - # pkg:gem/rubocop#lib/rubocop/cli.rb:39 + # pkg:gem/rubocop#lib/rubocop/cli.rb:40 def run(args = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cli.rb:162 + # pkg:gem/rubocop#lib/rubocop/cli.rb:163 def act_on_options; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:219 + # pkg:gem/rubocop#lib/rubocop/cli.rb:220 def apply_default_formatter; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:131 + # pkg:gem/rubocop#lib/rubocop/cli.rb:132 def execute_runners; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:205 + # pkg:gem/rubocop#lib/rubocop/cli.rb:206 def handle_editor_mode; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:209 + # pkg:gem/rubocop#lib/rubocop/cli.rb:210 def handle_exiting_options; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:150 + # pkg:gem/rubocop#lib/rubocop/cli.rb:151 def parallel_by_default!; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:87 + # pkg:gem/rubocop#lib/rubocop/cli.rb:88 def profile_if_needed; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:233 + # pkg:gem/rubocop#lib/rubocop/cli.rb:234 def report_pending_cops; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:119 + # pkg:gem/rubocop#lib/rubocop/cli.rb:120 def require_gem(name); end - # pkg:gem/rubocop#lib/rubocop/cli.rb:127 + # pkg:gem/rubocop#lib/rubocop/cli.rb:128 def run_command(name); end # Options that decide which cops run, as opposed to how configuration is loaded. # - # pkg:gem/rubocop#lib/rubocop/cli.rb:192 + # pkg:gem/rubocop#lib/rubocop/cli.rb:193 def set_cop_selection_options_to_config_loader; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:184 + # pkg:gem/rubocop#lib/rubocop/cli.rb:185 def set_options_to_config_loader; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:200 + # pkg:gem/rubocop#lib/rubocop/cli.rb:201 def set_options_to_pending_cops_reporter; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:139 + # pkg:gem/rubocop#lib/rubocop/cli.rb:140 def suggest_extensions; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:143 + # pkg:gem/rubocop#lib/rubocop/cli.rb:144 def validate_options_vs_config; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:237 + # pkg:gem/rubocop#lib/rubocop/cli.rb:238 def warn_if_cache_root_changed(early, desired); end end @@ -316,6 +316,44 @@ class RuboCop::CLI::Command::Base end end +# Shared handling for commands that take a list of cop names. +# +# Validation happens here rather than during option parsing because the +# registry is not complete until the configuration has been loaded, which +# is also why `--only` and `--except` are validated from the runner. +# @api private +# +# pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:12 +module RuboCop::CLI::Command::CopNames + private + + # Not memoized: the MCP server lives long enough for a plugin to register + # a cop after a lookup has missed it. + # + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:31 + def cop_class_for(name); end + + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:45 + def department?(name); end + + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:49 + def department_message(name); end + + # The cops among `names` that exist, so a command can report on what it + # understood before {#validate_cop_names!} objects to the rest. + # + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:17 + def known_cop_classes(names); end + + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:35 + def unknown_cop_message(name); end + + # @raise [IncorrectCopNameError] if any name is not a cop + # + # pkg:gem/rubocop#lib/rubocop/cli/command/cop_names.rb:22 + def validate_cop_names!(names); end +end + # Run all the selected cops and report the result. # @api private # @@ -370,6 +408,20 @@ end # pkg:gem/rubocop#lib/rubocop/cli/command/execute_runner.rb:12 RuboCop::CLI::Command::ExecuteRunner::INTEGRATION_FORMATTERS = T.let(T.unsafe(nil), Array) +# Explains what cops do, as described by {Cop::CopExplanation}. +# @api private +# +# pkg:gem/rubocop#lib/rubocop/cli/command/explain.rb:8 +class RuboCop::CLI::Command::Explain < ::RuboCop::CLI::Command::Base + include ::RuboCop::CLI::Command::CopNames + + # pkg:gem/rubocop#lib/rubocop/cli/command/explain.rb:13 + def initialize(env); end + + # pkg:gem/rubocop#lib/rubocop/cli/command/explain.rb:19 + def run; end +end + # Generate a .rubocop.yml file in the current directory. # @api private # @@ -426,87 +478,89 @@ end # # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:9 class RuboCop::CLI::Command::ShowCops < ::RuboCop::CLI::Command::Base - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:24 + include ::RuboCop::CLI::Command::CopNames + + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:26 def initialize(env); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:39 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:41 def run; end private - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:89 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:95 def config_lines(cop); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:85 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:91 def cops_of_department(cops, department); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:45 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:51 def print_available_cops; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:68 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:74 def print_cop_details(cops); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:56 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:62 def print_cops_of_department(registry, department, show_all); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:77 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:83 def selected_cops_of_department(cops, department); end end -# pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 +# pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 class RuboCop::CLI::Command::ShowCops::ExactMatcher < ::Struct - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:13 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:15 def match?(name); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def pattern; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def pattern=(_); end class << self - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def [](*_arg0); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def inspect; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def keyword_init?; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def members; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:12 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:14 def new(*_arg0); end end end -# pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 +# pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 class RuboCop::CLI::Command::ShowCops::WildcardMatcher < ::Struct - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:19 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:21 def match?(name); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def pattern; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def pattern=(_); end class << self - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def [](*_arg0); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def inspect; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def keyword_init?; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def members; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_cops.rb:20 def new(*_arg0); end end end @@ -517,18 +571,20 @@ end # # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:9 class RuboCop::CLI::Command::ShowDocsUrl < ::RuboCop::CLI::Command::Base - # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:12 + include ::RuboCop::CLI::Command::CopNames + + # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:14 def initialize(env); end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:18 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:20 def run; end private - # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:38 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:40 def cops_array; end - # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:24 + # pkg:gem/rubocop#lib/rubocop/cli/command/show_docs_url.rb:29 def print_documentation_url; end end @@ -631,7 +687,7 @@ class RuboCop::CLI::Environment def run(name); end end -# pkg:gem/rubocop#lib/rubocop/cli.rb:20 +# pkg:gem/rubocop#lib/rubocop/cli.rb:21 class RuboCop::CLI::Finished < ::StandardError; end # pkg:gem/rubocop#lib/rubocop/cli.rb:11 @@ -682,15 +738,33 @@ class RuboCop::CachedData private + # A corrector cannot be serialized, so the edits it would make are cached + # separately; without this a cache hit would report no corrections. + # + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:67 + def add_corrections(hash, offense); end + + # Only offenses suppressed by a directive can carry one, so keep the key out of the + # common case rather than writing a null for every cached offense. + # + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:59 + def add_justification(hash, offense); end + + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:89 + def corrections_from_cache(offense); end + # Restore an offense object loaded from a JSON file. # - # pkg:gem/rubocop#lib/rubocop/cached_data.rb:51 + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:79 def deserialize_offenses(offenses); end - # pkg:gem/rubocop#lib/rubocop/cached_data.rb:59 + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:47 + def encode_to_utf8(value); end + + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:99 def location_from_source_buffer(offense); end - # pkg:gem/rubocop#lib/rubocop/cached_data.rb:44 + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:43 def message(offense); end # pkg:gem/rubocop#lib/rubocop/cached_data.rb:23 @@ -700,7 +774,7 @@ class RuboCop::CachedData # and be global only. For these, trying to create the buffer will likely fail, for example # because of unknown encoding comments. # - # pkg:gem/rubocop#lib/rubocop/cached_data.rb:72 + # pkg:gem/rubocop#lib/rubocop/cached_data.rb:112 def source_buffer; end end @@ -713,9 +787,14 @@ end # # pkg:gem/rubocop#lib/rubocop/changed_files.rb:12 class RuboCop::ChangedFiles - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:16 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:25 def initialize(revision = T.unsafe(nil)); end + # @return [Array] the files among these that changed + # + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:42 + def filter(files); end + # Files that were added or modified since the revision, as absolute paths. # Deleted files are left out - there is nothing left to inspect - and # untracked files are included, since a file that is new to the working @@ -723,11 +802,17 @@ class RuboCop::ChangedFiles # # @return [Set] # - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:26 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:35 def paths; end private + # Hashed rather than hardcoded, since its id depends on the repository's + # object format (SHA-1 or SHA-256). + # + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:75 + def empty_tree; end + # git hands back bytes, which Ruby tags with the encoding the process # happens to have been started in - splitting those bytes as US-ASCII raises # on any path that is not. They have to end up in the encoding `Dir.glob` @@ -739,33 +824,40 @@ class RuboCop::ChangedFiles # the way out, while Ruby reports file names in the local code page, so the # two have to be reconciled. # - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:83 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:105 def filesystem_path(path); end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:95 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:117 def git(*args); end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:105 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:127 def git_error_message(stderr); end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:38 - def modified_paths; end + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:53 + def modified_paths(revision = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:34 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:49 def repository_root; end # The `-z` above is what makes these usable: without it git wraps any path # that is not plain ASCII in quotes and octal escapes, and those files drop # out of the comparison without a word. # - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:69 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:91 def split_paths(output); end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:53 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:69 def unborn_head?; end - # pkg:gem/rubocop#lib/rubocop/changed_files.rb:60 + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:79 def untracked_paths; end + + class << self + # Whether git can resolve `name` to a commit in the current repository. + # + # pkg:gem/rubocop#lib/rubocop/changed_files.rb:17 + def revision?(name); end + end end # pkg:gem/rubocop#lib/rubocop/changed_files.rb:13 @@ -813,12 +905,15 @@ class RuboCop::CommentConfig # The names of the cops that are opted in by an `enable` comment directive # or a `+` argument of a `push`/`next` directive, used to mobilize cops - # disabled in the config on demand. + # disabled in the config on demand. Departments are expanded for the + # opt-in forms only: a plain `enable` naming a department usually just + # closes a `disable` of it, and expanding it would switch on every + # config-disabled cop of the department for the rest of the file. # # @api private # @return [Set] # - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:85 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:88 def opt_in_cops; end # pkg:gem/rubocop#lib/rubocop/comment_config.rb:30 @@ -829,60 +924,63 @@ class RuboCop::CommentConfig private - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:117 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:126 def analyze; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:161 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:170 def analyze_cop(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:181 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:190 def analyze_disabled(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:185 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:194 def analyze_rest(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:172 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:181 def analyze_single_line(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:189 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:198 def cop_line_ranges(analysis); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:193 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:202 def each_directive; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:101 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:98 def extra_enabled_comments_with_names(extras:, names:); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:234 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:243 def handle_enable_all(directive, names, extras); end # Collect cops that have been disabled or enabled by name in a directive comment # so that `Lint/RedundantCopEnableDirective` can register offenses correctly. # - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:248 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:257 def handle_switch(directive, names, extras); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:152 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:161 def inject_disabled_cops_directives(analyses); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:227 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:236 def non_comment_token_line_numbers; end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:113 + def opted_in_by(directive); end + # `Style/DisableCopsWithinSourceCodeDirective` cannot be disabled via # directive comments when it is explicitly enabled with `Enabled: true`. # This prevents users from bypassing the cop by writing a disable # directive that targets this cop itself. # - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:222 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:231 def prevent_directive_disabling?(cop_name); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:209 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:218 def qualified_cop_name(cop_name); end # Push/pop and next-statement directives close themselves, so they # play no part in the disable/enable pairing. # - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:204 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:213 def self_closing_directive?(directive); end end @@ -1541,14 +1639,14 @@ class RuboCop::ConfigLoader # Used to add features that were required inside a config or from # the CLI using `--require`. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:225 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:228 def add_loaded_features(loaded_features); end # @api private # Used to add plugins that were required inside a config or from # the CLI using `--plugin`. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:218 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:221 def add_loaded_plugins(loaded_plugins); end # pkg:gem/rubocop#lib/rubocop/config_loader.rb:94 @@ -1562,7 +1660,7 @@ class RuboCop::ConfigLoader # configuration and still need the same treatment `merge_with_default` # would have given them. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:203 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:206 def apply_default_overrides(config); end # pkg:gem/rubocop#lib/rubocop/config_loader.rb:35 @@ -1669,8 +1767,8 @@ class RuboCop::ConfigLoader # Merges the given configuration with the default one. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:192 - def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:193 + def merge_with_default(config, config_file, unset_nil: T.unsafe(nil), resolve_preview: T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/config_loader.rb:26 def preview; end @@ -1682,31 +1780,31 @@ class RuboCop::ConfigLoader # searches will go past this directory. # @deprecated Use `RuboCop::ConfigFinder.project_root` instead. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:182 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:183 def project_root; end private - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:239 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:242 def check_duplication(yaml_code, absolute_path); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:231 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:234 def file_path(file); end # Read the specified file, or exit with a friendly, concise message on # stderr. Care is taken to use the standard OS exit code for a "file not # found" error. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:259 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:262 def read_file(absolute_path); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:235 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:238 def resolver; end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:265 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:268 def yaml_tree_to_hash(yaml_tree); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:275 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:278 def yaml_tree_to_hash!(yaml_tree); end end end @@ -1730,7 +1828,7 @@ class RuboCop::ConfigLoaderResolver # `Preview` those replace the current defaults. The section is dropped either # way, so the resolved configuration only ever shows what is in effect. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:176 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:182 def apply_preview_defaults(default_configuration, preview); end # When one .rubocop.yml file inherits from another .rubocop.yml file, the Include paths in the @@ -1738,14 +1836,14 @@ class RuboCop::ConfigLoaderResolver # derived configuration, we need to make those paths relative to where the derived configuration # file is. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:65 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:66 def fix_include_paths(base_config_path, hash, path, key, value); end # Return a recursive merge of two hashes. That is, a normal hash merge, # with the addition that any value that is a hash, and occurs in both # arguments, will also be merged. And so on. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:122 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:128 def merge(base_hash, derived_hash, **opts); end # Merges the given configuration with the default one. If @@ -1756,25 +1854,30 @@ class RuboCop::ConfigLoaderResolver # When the `--disable-all-cops` or `--enable-all-cops` CLI option is given, # it takes precedence over the configuration values. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:97 - def merge_with_default(config, config_file, unset_nil:); end + # With `resolve_preview: false` the `Preview` sections of the default + # configuration are left in place and preview is treated as off. That is + # what extending the default configuration itself needs: preview gets + # applied later, when a project configuration is resolved against it. + # + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:103 + def merge_with_default(config, config_file, unset_nil:, resolve_preview: T.unsafe(nil)); end # An `Enabled: true` setting in user configuration for a cop overrides an # `Enabled: false` setting for its department. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:141 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:147 def override_department_setting_for_cops(base_hash, derived_hash); end # If a cop was previously explicitly enabled, but then superseded by the # department being disabled, disable it. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:158 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:164 def override_enabled_for_disabled_departments(base_hash, derived_hash); end # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:38 def resolve_inheritance(path, hash, file, debug); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:75 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:76 def resolve_inheritance_from_gems(hash); end # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:11 @@ -1785,62 +1888,73 @@ class RuboCop::ConfigLoaderResolver private - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:284 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:309 def base_configs(path, inherit_from, file); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:252 - def determine_inherit_mode(hash, key); end + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:194 + def defaults_with_preview(config, resolve_preview); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:221 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:277 + def determine_inherit_mode(hash, key, preview); end + + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:235 def disabled?(hash, department); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:225 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:239 def duplicate_setting?(base_hash, derived_hash, key, inherited_file); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:246 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:260 def duplicate_setting_warning(opts, key); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:343 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:368 def gem_config_path(gem_name, relative_config_path); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:321 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:346 def handle_disabled_by_default(config, new_default_configuration, base_defaults); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:188 - def inherit_mode_for_default(config); end + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:202 + def inherit_mode_for_default(config, preview); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:296 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:321 def inherited_file(path, inherit_from, file); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:280 + # The `AllCops: Preview` in effect once inheritance is resolved: the file + # itself wins, then the files it inherits from, last one first. It has to be + # known before merging, since the keys are merged in whatever order they + # appear and `AllCops` may well come after the cops whose `Exclude` it affects. + # + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:270 + def inherited_preview?(hash, base_configs); end + + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:305 def merge_hashes?(base_hash, derived_hash, key); end # `config` has already been through `handle_disabled_by_default` by this # point, which returns a plain hash, so read `AllCops` directly rather than # going through `Config#for_all_cops`. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:207 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:221 def preview?(config); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:317 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:342 def remote_config?(file); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:213 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:227 def resolve_default_overrides(config); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:272 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:297 def should_merge?(mode, key); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:276 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:301 def should_override?(mode, key); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:258 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:283 def should_union?(derived_hash, base_hash, root_mode, key); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:339 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:364 def transform(config, &block); end - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:234 + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:248 def warn_on_duplicate_setting(base_hash, derived_hash, key, **opts); end # Under `Preview`, `Exclude` is merged rather than replaced, so that excluding @@ -1848,8 +1962,8 @@ class RuboCop::ConfigLoaderResolver # from the default configuration or from a file named in `inherit_from`. An # explicit `inherit_mode` still wins, in either direction. # - # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:196 - def with_preview_exclude_merge(mode, config); end + # pkg:gem/rubocop#lib/rubocop/config_loader_resolver.rb:210 + def with_preview_exclude_merge(mode, preview); end end # Raised when a RuboCop configuration file is not found. @@ -2307,7 +2421,7 @@ class RuboCop::ConfigValidator # pkg:gem/rubocop#lib/rubocop/config_validator.rb:102 def alert_about_unrecognized_cops(invalid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:315 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:326 def check_cop_config_value(hash, parent = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:75 @@ -2316,27 +2430,27 @@ class RuboCop::ConfigValidator # pkg:gem/rubocop#lib/rubocop/config_validator.rb:82 def check_target_ruby; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:254 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:265 def each_invalid_parameter(cop_name); end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:118 def list_unknown_cops(invalid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:211 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:222 def new_cops_value_for_department(name, section); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:218 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:229 def new_cops_version_value?(value); end # FIXME: Handling colors in exception messages like this is ugly. # - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:336 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:347 def param_error_message(parent, key, value, supposed_values); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:304 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:315 def reject_conflicting_safe_settings; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:295 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:306 def reject_mutually_exclusive_defaults; end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:141 @@ -2345,31 +2459,34 @@ class RuboCop::ConfigValidator # pkg:gem/rubocop#lib/rubocop/config_validator.rb:73 def target_ruby; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:188 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:199 def validate_all_cops_new_cops_parameter; end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:173 def validate_all_cops_parameters; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:199 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:210 def validate_department_new_cops_parameters; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:269 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:280 def validate_enforced_styles(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:178 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:179 def validate_fail_level_parameter; end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:168 def validate_new_cops_parameter; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:240 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:251 def validate_parameter_names(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:226 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:237 def validate_parameter_shape(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:289 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:189 + def validate_preview_parameter; end + + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:300 def validate_support_and_has_list(name, formats, valid); end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:157 @@ -2417,7 +2534,7 @@ module RuboCop::Cop; end module RuboCop::Cop::Alignment private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:30 def check_alignment(items, base_column = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:12 @@ -2428,33 +2545,36 @@ module RuboCop::Cop::Alignment # @api public # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:62 def display_column(range); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:49 def each_bad_alignment(items, base_column); end # @deprecated Use processed_source.line_with_comment?(line) # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:73 def end_of_line_comment(line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:18 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:22 def indentation(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:22 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:26 def offset(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:82 def register_offense(offense_node, message_node); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:18 + def using_tabs?; end + # @api public # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/alignment.rb:68 def within?(inner, outer); end end @@ -2487,16 +2607,16 @@ class RuboCop::Cop::AlignmentCorrector private - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:180 def alignment_column(align_to); end # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:55 def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:148 def block_comment_within?(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:154 def calculate_range(expr, line_begin_pos, column_delta); end # The number of columns a single tab spans. This must match the width @@ -2525,28 +2645,34 @@ class RuboCop::Cop::AlignmentCorrector # nil. # - The source map of `__FILE__` responds to neither :begin nor :end. # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:144 def delimited_string_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:166 def each_line(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:190 def indentation_string(column); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:129 def inside_string_range(node); end # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:111 def inside_string_ranges(node); end + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:117 + def source_string_ranges; end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:125 + def string_ranges(node); end + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:93 def target_tab_indentation(leading, column_delta); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:198 def using_tabs?; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:162 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:174 def whitespace_range(node); end end end @@ -2797,55 +2923,63 @@ module RuboCop::Cop::AutocorrectLogic private - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:59 + # When LSP is enabled or the `--editor-mode` option is on, it is considered as editing + # source code, and autocorrection with `AutoCorrect: contextual` will not be performed. + # The `editing` option says the same without the rest of LSP mode, which + # is about showing offenses in an editor. + # + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:60 + def contextual_autocorrect_held_back?; end + + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:64 def disable_offense(offense_range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:157 def disable_offense_at_end_of_line(range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:165 def disable_offense_before_and_after(range_by_lines); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:91 def disable_offense_with_eol_or_surround_comment(range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:161 def eol_comment; end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:99 def eol_comment_would_be_inside_literal?(offense_range, literal_range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:116 def heredoc_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:106 def line_with_eol_comment_too_long?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:151 def max_line_length; end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:77 def multiline_ranges(offense_range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:128 def multiline_string?(node); end # Expand the given range to include all of any lines it covers. Does not # include newline at end of the last line. # - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:141 def range_by_lines(range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:132 def range_of_first_line(range); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:124 def string_continuation?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:112 def surrounding_heredoc?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/autocorrect_logic.rb:120 def surrounding_percent_array?(node); end end @@ -2953,7 +3087,7 @@ class RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/base.rb:164 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:288 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:293 def active_support_extensions_enabled?; end # Adds an offense that has no particular location. @@ -2972,43 +3106,48 @@ class RuboCop::Cop::Base # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:375 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:380 def always_autocorrect?; end # Called before any investigation # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:361 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:366 def begin_investigation(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:343 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:348 def callbacks_needed; end # pkg:gem/rubocop#lib/rubocop/cop/base.rb:43 def config; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:262 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:256 def config_to_allow_offenses; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:266 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:260 def config_to_allow_offenses=(hash); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:381 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:386 def contextual_autocorrect?; end # Configuration Helpers # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:250 def cop_config; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:242 def cop_name; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:312 + # @api private + # + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:391 + def disabled_autocorrect?; end + + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:317 def excluded_file?(file); end # This method should be overridden when a cop's behavior depends @@ -3027,10 +3166,10 @@ class RuboCop::Cop::Base # ResultCache system when those external dependencies change, # ie when the ResultCache should be invalidated. # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:244 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:238 def external_dependency_checksum; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:385 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:396 def inspect; end # Gets called if no message is specified when calling `add_offense` or @@ -3040,12 +3179,12 @@ class RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/base.rb:191 def message(_range = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:246 def name; end # @deprecated Make potential errors with previous API more obvious # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:334 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:339 def offenses; end # Called after all on_... have been called @@ -3068,17 +3207,17 @@ class RuboCop::Cop::Base # There should be very limited reasons for a Cop to do it's own parsing # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:322 def parse(source, path = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:285 def parser_engine; end # Whether the user opted in to unstable behavior, with `--preview` or # `AllCops: Preview`. Cops branch on this to ship a change that is not # ready to be the default yet. # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:304 def preview?; end # pkg:gem/rubocop#lib/rubocop/cop/base.rb:43 @@ -3093,126 +3232,141 @@ class RuboCop::Cop::Base # @api private # Called between investigations # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:323 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:328 def ready; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:303 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:308 def relevant_file?(file); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:297 def string_literals_frozen_by_default?; end - # Returns a gems locked versions (i.e. from Gemfile.lock or gems.locked) - # @returns [Gem::Version | nil] The locked gem version, or nil if the gem is not present. + # Returns the version of a gem in the target, by default its locked version + # (i.e. from Gemfile.lock or gems.locked). + # + # The requirements declared with `requires_gem` are checked against the version + # this method returns, so an extension that lets users state the version of its + # gem in `AllCops` (e.g. `TargetFrameworkVersion`) can override it for that gem, + # returning a `Gem::Version`, and fall back to `super` for any other gem. + # + # @param [String] gem_name + # @return [Gem::Version, nil] The gem version, or nil if the gem is not present. + # + # @api public # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:280 def target_gem_version(gem_name); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:284 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:289 def target_rails_version; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:264 def target_ruby_version; end private - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:512 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:540 def annotate(message); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:403 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:430 def apply_correction(corrector); end # @return [Symbol] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:476 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:504 def attempt_correction(range, corrector); end # Reserved for Cop::Cop # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:399 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:426 def callback_argument(range); end # Called to complete an investigation # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:428 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:455 def complete_investigation; end # @return [Symbol, Corrector] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:446 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:473 def correct(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:564 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:592 def covering_disabled_range(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:417 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:444 def current_corrector; end # Reserved for Commissioner: # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:409 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:436 def current_offense_locations; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:448 def current_offenses; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:413 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:440 def currently_disabled_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:579 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:607 def custom_severity; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:575 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:603 def default_severity; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:490 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:518 def disable_uncorrectable(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:541 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:569 def enabled_line?(line_number); end # A multi-line offense is suppressed by a directive on any line of its # range, not only its first line, matching the intuition that the # directive is attached to the offending code. # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:550 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:578 def enabled_lines?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:518 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:546 def file_name_matches_any?(file, parameter, default_result); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:508 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:536 def find_message(range, message); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:571 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:599 def find_severity(_range, severity); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:533 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:561 def matches_absolute_include_pattern?(patterns, file); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:592 + # @return [Offense] + # + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:409 + def new_offense(range, severity, message, status, corrector); end + + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:620 def range_for_original(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:497 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:525 def range_from_node_or_range(node_or_range); end # Actually private methods # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:438 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:465 def reset_investigation; end # The `--` reason on the directive that suppresses offenses on this # range, or `nil` when the directive carries none. # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:559 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:587 def suppression_reason(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:603 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:631 def target_satisfies_all_gem_version_requirements?; end # @return [Symbol] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:461 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:488 def use_corrector(range, corrector); end class << self @@ -3233,7 +3387,7 @@ class RuboCop::Cop::Base # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:348 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:353 def callbacks_needed; end # pkg:gem/rubocop#lib/rubocop/cop/base.rb:103 @@ -3314,7 +3468,7 @@ class RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:393 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:404 def restrict_on_send; end end end @@ -3326,7 +3480,7 @@ end # pkg:gem/rubocop#lib/rubocop/cop/base.rb:57 RuboCop::Cop::Base::DEPARTMENT_SEVERITIES = T.let(T.unsafe(nil), Hash) -# pkg:gem/rubocop#lib/rubocop/cop/base.rb:425 +# pkg:gem/rubocop#lib/rubocop/cop/base.rb:452 RuboCop::Cop::Base::EMPTY_OFFENSES = T.let(T.unsafe(nil), Array) # Reports of an investigation. @@ -3613,74 +3767,72 @@ RuboCop::Cop::Bundler::DuplicatedGroup::SOURCE_BLOCK_NAMES = T.let(T.unsafe(nil) # # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:83 class RuboCop::Cop::Bundler::GemComment < ::RuboCop::Cop::Base - include ::RuboCop::Cop::VisibilityHelp - include ::RuboCop::Cop::DefNode include ::RuboCop::Cop::GemDeclaration - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:93 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:134 def checked_options_present?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:108 def commented?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:104 def commented_any_descendant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:158 def contains_checked_options?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:162 def gem_options(node); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:129 def ignored_gem?(node); end # The args node1 & node2 may represent a RuboCop::AST::Node # or a Parser::Source::Comment. Both respond to #loc. # - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:115 def precede?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:125 def preceding_comment?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:119 def preceding_lines(node); end # Version specifications that restrict all updates going forward. This excludes versions # like ">= 1.0" or "!= 2.0.3". # - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:151 def restrictive_version_specified_gem?(node); end # Besides the gem name, all other *positional* arguments to `gem` are version specifiers, # as long as it has one we know there's at least one version specifier. # - # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:144 def version_specified_gem?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:88 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:87 RuboCop::Cop::Bundler::GemComment::CHECKED_OPTIONS_CONFIG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:87 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:86 RuboCop::Cop::Bundler::GemComment::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:91 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:90 RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:90 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:89 RuboCop::Cop::Bundler::GemComment::RESTRICTIVE_VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:92 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:91 RuboCop::Cop::Bundler::GemComment::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:89 +# pkg:gem/rubocop#lib/rubocop/cop/bundler/gem_comment.rb:88 RuboCop::Cop::Bundler::GemComment::VERSION_SPECIFIERS_OPTION = T.let(T.unsafe(nil), String) # Verifies that a project contains Gemfile or gems.rb file and correct @@ -3956,16 +4108,11 @@ class RuboCop::Cop::Bundler::OrderedGems < ::RuboCop::Cop::Base include ::RuboCop::Cop::OrderedGemNode extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/bundler/ordered_gems.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/bundler/ordered_gems.rb:55 def gem_declarations(param0); end # pkg:gem/rubocop#lib/rubocop/cop/bundler/ordered_gems.rb:43 def on_new_investigation; end - - private - - # pkg:gem/rubocop#lib/rubocop/cop/bundler/ordered_gems.rb:56 - def previous_declaration(node); end end # pkg:gem/rubocop#lib/rubocop/cop/bundler/ordered_gems.rb:39 @@ -4065,42 +4212,42 @@ module RuboCop::Cop::CheckLineBreakable # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:223 def all_on_same_line?(nodes); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:243 def already_on_multiple_lines?(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:142 def breakable_collection?(node, elements); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:246 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:249 def chained_to_heredoc?(node); end # @api private # The result depends only on the given node, but the check may traverse all children of # a large collection and is repeated for each contained element, so memoize it per node. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:195 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:198 def children_could_be_broken_up?(node, children); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:210 def compute_children_could_be_broken_up?(children); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:157 def contained_by_breakable_collection_on_same_line?(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:174 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:177 def contained_by_multiline_collection_that_could_be_broken_up?(node); end # @api private @@ -4120,24 +4267,29 @@ module RuboCop::Cop::CheckLineBreakable # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:115 + def heredoc_begin_position(node); end + + # @api private + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:230 def process_args(args); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:128 def safe_to_ignore?(node); end # @api private # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen # after the heredoc or else it will cause a syntax error. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:103 def shift_elements_for_heredoc_arg(node, elements, index); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:123 def within_column_limit?(element, max, line); end end @@ -4151,17 +4303,20 @@ module RuboCop::Cop::CheckSingleLineSuitability private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:36 def comment_within?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:40 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:44 def safe_to_split?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:23 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:27 def to_single_line(source); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:16 def too_long?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_single_line_suitability.rb:20 + def too_long_as_single_line?(line_range); end end # Common functionality for checking length of code segments. @@ -4187,6 +4342,12 @@ module RuboCop::Cop::CodeLength # pkg:gem/rubocop#lib/rubocop/cop/mixin/code_length.rb:23 def count_comments?; end + # Where the header of a definition ends: the name of a class, module or + # method, the `self` of `class << self`, or the opening of a block. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/code_length.rb:70 + def header_end(node); end + # Returns true for lines that shall not be included in the count. # # pkg:gem/rubocop#lib/rubocop/cop/mixin/code_length.rb:45 @@ -5027,6 +5188,128 @@ class RuboCop::Cop::Cop::Correction < ::Struct end end +# Reads the documentation comment a cop carries above its class definition +# and splits it into the sections worth showing on their own. +# +# YARD is a development dependency, so the comment is read straight from the +# source rather than through a doclet. +# @api private +# +# pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:11 +class RuboCop::Cop::CopDocumentation + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:14 + def initialize(cop_class); end + + # @return [Array)>] title and body per section + # + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:19 + def sections; end + + private + + # Walks up from the class definition for as long as the lines are comments. + # + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:48 + def collect_comment_above(lines, index); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:30 + def comment_lines; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:71 + def section_title(tag, argument); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:38 + def source_location; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:57 + def split_on_first_tag(comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:76 + def strip_blank(lines); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:64 + def tagged_sections(lines); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/cop_documentation.rb:12 +RuboCop::Cop::CopDocumentation::TAG = T.let(T.unsafe(nil), Regexp) + +# Explains what a single cop does: its description, how it is configured, +# whether it corrects, and the examples from its own documentation. +# +# Rendered as plain text, which is what `--explain` prints and what the MCP +# server hands to an agent. +# @api private +# +# pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:11 +class RuboCop::Cop::CopExplanation + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:19 + def initialize(cop_class, config); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:25 + def to_s; end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:88 + def autocorrect_description; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:109 + def configuration_lines; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:51 + def description_lines; end + + # The comment above the class opens by restating the description, which + # is already printed above, so that opening is dropped. + # + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:127 + def documentation_sections(description); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:115 + def format_value(value); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:31 + def lines; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:74 + def patterns_line(label, patterns); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:55 + def property_lines; end + + # `Exclude` patterns are absolutized against the config that set them, + # which makes for a wall of identical prefixes. A user config can also + # hold a regexp rather than a glob. + # + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:84 + def readable_pattern(pattern); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:119 + def reference_lines; end + + # Which files the cop looks at. A cop that only runs on Gemfiles + # explains an absent offense better than anything else here does. + # + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:67 + def scope_lines; end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:44 + def section(title, body); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:135 + def strip_blank(lines); end + + # pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:102 + def version_lines; end +end + +# Keys that describe the cop to RuboCop itself rather than something a +# user would set, so they are reported in their own section or not at all. +# +# pkg:gem/rubocop#lib/rubocop/cop/cop_explanation.rb:14 +RuboCop::Cop::CopExplanation::METADATA_KEYS = T.let(T.unsafe(nil), Array) + # This class takes a source buffer and rewrite its source # based on the different correction rules supplied. # @@ -5315,20 +5598,26 @@ class RuboCop::Cop::EachToForCorrector private - # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:25 def argument_node; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:25 def block_node; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:24 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:41 + def closing_keyword; end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:25 def collection_node; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:27 def correction; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:36 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:51 def offending_range; end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:45 + def padding_needed?(position); end end # pkg:gem/rubocop#lib/rubocop/cop/correctors/each_to_for_corrector.rb:10 @@ -5402,6 +5691,42 @@ end # pkg:gem/rubocop#lib/rubocop/cop/mixin/end_keyword_alignment.rb:10 RuboCop::Cop::EndKeywordAlignment::MSG = T.let(T.unsafe(nil), String) +# Common functionality for checking whether a method body can become the +# body of an endless method definition without changing its meaning. +# +# pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:7 +module RuboCop::Cop::EndlessMethodBodyHelp + private + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:54 + def assigned_value(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:61 + def command_call?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:46 + def command_disallowed_in_endless_body?(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:10 + def endless_method_body?(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:37 + def ends_with_anonymous_argument?(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:31 + def ends_with_omitted_hash_value?(body); end + + # `def foo = bar and baz` parses as `(def foo = bar) and baz`. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:20 + def low_precedence_body?(body); end + + # `foo = 1, 2` and `foo = *bar` assign an array without brackets. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_body_help.rb:27 + def multiple_values?(node); end +end + # Common functionality for rewriting endless methods to normal method definitions # # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_rewriter.rb:6 @@ -5817,7 +6142,7 @@ class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:112 def add_dependency_method?(method_name); end # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:96 @@ -5826,28 +6151,25 @@ class RuboCop::Cop::Gemspec::DependencyVersion < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:100 def allowed_gems; end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:126 def forbidden_offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:132 def forbidden_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:112 - def match_block_variable_name?(receiver_name); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:104 def message(_range); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:116 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:120 def required_offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:136 def required_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/dependency_version.rb:140 def version_specification?(expression); end end @@ -6149,7 +6471,7 @@ class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base include ::RuboCop::Cop::OrderedGemNode extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:88 def dependency_declarations(param0); end # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:69 @@ -6157,11 +6479,8 @@ class RuboCop::Cop::Gemspec::OrderedDependencies < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:89 - def get_dependency_name(node); end - # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:83 - def previous_declaration(node); end + def get_dependency_name(node); end end # pkg:gem/rubocop#lib/rubocop/cop/gemspec/ordered_dependencies.rb:65 @@ -6695,9 +7014,9 @@ end # This is a special case that just ensures the kwsplat is aligned with the rest of the hash # since a `kwsplat` does not have a key, separator or value. # -# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:173 +# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:187 class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:174 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:188 def deltas(first_pair, current_pair); end end @@ -6707,18 +7026,27 @@ end class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + # Keys are right-aligned by the column their last line ends on. + # A key spanning several lines ends on a line other than the one it starts on, + # so moving its first line would never change that column and the correction + # would be repeated on every pass. Such pairs are left alone, and so is every pair + # when the first key spans several lines, since there is then no column to right-align to. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:160 + def deltas(first_pair, current_pair); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:151 def deltas_for_first_pair(_first_pair); end private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:172 def hash_rocket_delta(first_pair, current_pair); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:168 def key_delta(first_pair, current_pair); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:176 def value_delta(first_pair, current_pair); end end @@ -6787,78 +7115,84 @@ end # # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:7 module RuboCop::Cop::HashShorthandSyntax - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:41 def on_hash_for_mixed_shorthand(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:44 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:53 def on_pair(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:165 def brackets?(method_dispatch_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:195 def breakdown_value_types_of_hash(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:143 def def_node_that_require_parentheses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:224 def each_omittable_value_pair(hash_value_type_breakdown, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:220 def each_omitted_value_pair(hash_value_type_breakdown, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:121 def enforced_shorthand_syntax; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:157 def find_ancestor_method_dispatch_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:108 def hash_rockets_enforced?(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:207 def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:211 def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:215 def ignore_explicit_omissible_hash_shorthand_syntax?(hash_value_type_breakdown); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:102 def ignore_hash_shorthand_syntax?(pair_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:96 def ignore_mixed_hash_shorthand_syntax?(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:162 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:257 + def keyword_value?(pair_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:180 def last_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:228 def mixed_shorthand_syntax_check(hash_value_type_breakdown); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:113 + def no_mixed_keys_enforces_hash_rockets?(pairs); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:246 def no_mixed_shorthand_syntax_check(hash_value_type_breakdown); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:76 def register_offense(node, message, replacement); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:125 def require_hash_value?(hash_key_source, node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:134 def require_hash_value_for_around_hash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:188 def requires_parentheses_context?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:169 def use_element_of_hash_literal_as_receiver?(ancestor, parent); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:174 def use_modifier_form_without_parenthesized_method_call?(ancestor); end end @@ -6871,37 +7205,37 @@ RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_MSG_PREFIX = T.let(T.unsafe(nil), # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:11 RuboCop::Cop::HashShorthandSyntax::DO_NOT_MIX_OMIT_VALUE_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 +# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 class RuboCop::Cop::HashShorthandSyntax::DefNode < ::Struct - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:32 def first_argument; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:27 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:36 def last_argument; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def node; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def node=(_); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:15 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:24 def selector; end class << self - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def [](*_arg0); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def inspect; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def keyword_init?; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def members; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:14 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:23 def new(*_arg0); end end end @@ -6909,6 +7243,13 @@ end # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:9 RuboCop::Cop::HashShorthandSyntax::EXPLICIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) +# A keyword parameter can be named after a keyword, as in `def foo(if:)`, +# but the parameter can only be referenced by an omitted hash value, +# so `{ if: }` has no explicit form: `{ if: if }` is invalid Ruby. +# +# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:17 +RuboCop::Cop::HashShorthandSyntax::KEYWORDS = T.let(T.unsafe(nil), Set) + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:8 RuboCop::Cop::HashShorthandSyntax::OMIT_HASH_VALUE_MSG = T.let(T.unsafe(nil), String) @@ -7378,66 +7719,75 @@ class RuboCop::Cop::LambdaLiteralToMethodCorrector # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:13 def call(corrector); end + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:32 + def replace_delimiters?; end + private - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:128 def arg_to_unparenthesized_call?; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:148 + def argument_source(argument); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:38 def arguments; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:112 def arguments_begin_pos; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:108 def arguments_end_pos; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:120 def block_begin; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:116 def block_end; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:38 def block_node; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:63 def insert_arguments(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:47 def insert_separating_space(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:92 def lambda_arg_string; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:38 def method; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:102 def needs_separating_space?; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:158 + def operator_expression?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:57 def remove_arguments(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:70 def remove_leading_whitespace(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:78 def remove_trailing_whitespace(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:36 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:40 def remove_unparenthesized_whitespace(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:83 def replace_delimiters(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:49 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:53 def replace_selector(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:124 def selector_end; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb:144 def separating_space?; end end @@ -7850,74 +8200,78 @@ RuboCop::Cop::Layout::BeginEndAlignment::MSG = T.let(T.unsafe(nil), String) # # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:70 class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:79 def block_end_align_target?(param0 = T.unsafe(nil), param1); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:89 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:94 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:93 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:96 def style_parameter_name; end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:263 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:290 def add_space_before(corrector, loc, delta); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:267 def alt_start_msg(start_loc, source_line_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:166 + def anchor_indentation(ancestor_node, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:152 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:102 def block_end_align_target(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:120 def check_block_alignment(start_node, block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:229 def compute_do_source_line_column(node, end_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:282 def compute_start_col(ancestor_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:116 def disqualified_parent?(parent, node); end # When the `do` or `{` is on a continuation line of multiline method # arguments, the indentation of that line is not a meaningful # alignment target; anchor on the method dispatch position instead. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:303 def do_line_anchor_loc(node, do_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:312 def do_line_begins_inside_argument?(node, do_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:112 def end_align_target?(node, parent); end # In offense message, we want to show the assignment LHS rather than # the entire assignment. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:224 def find_lhs_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:195 def format_message(start_loc, end_loc, do_source_line_column, error_source_line_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:277 def format_source_line_column(source_line_column); end # The continuation line indentation is only an unmeaningful alignment target when @@ -7925,33 +8279,39 @@ class RuboCop::Cop::Layout::BlockAlignment < ::RuboCop::Cop::Base # For a bare argument list without parentheses the indentation is the author's # deliberate alignment, so the anchor must not move to the method dispatch line. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:300 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:327 def inside_parentheses?(node, pos); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:259 def loc_to_source_line_column(loc); end # `end` aligned with an argument continuation line that holds the `do` # was accepted before the anchor moved to the method dispatch line; # keep accepting it so that such code does not become an offense. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:253 def permitted_do_line_columns(do_loc, indentation_of_do_line); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:134 def register_offense(block_node, start_loc, end_loc, do_source_line_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:294 def remove_space_before(corrector, end_pos, delta); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:175 + def replace_end_indentation(corrector, node, indentation); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:183 + def shift_end_to_start_col(corrector, ancestor_node, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:205 def start_for_block_node(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:212 def start_for_line_node(block_node); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:75 +# pkg:gem/rubocop#lib/rubocop/cop/layout/block_alignment.rb:76 RuboCop::Cop::Layout::BlockAlignment::MSG = T.let(T.unsafe(nil), String) # Checks whether the end statement of a do..end block @@ -8130,13 +8490,19 @@ class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:195 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:201 def base_column(case_node, base); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:228 + def base_location(case_node, base); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:152 def check_when(when_node, branch_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:221 + def configured_base_location(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:190 def detect_incorrect_style(when_node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:138 @@ -8145,19 +8511,22 @@ class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:148 def enforced_style_end?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:175 def incorrect_style(when_node, branch_type); end # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:163 def indent_one_step?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:167 + # Under tabs one step is a single tab character, which counts as one column + # regardless of the configured indentation width. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:169 def indentation_width; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:212 def replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:205 def whitespace_range(node); end end @@ -8349,10 +8718,10 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # Consecutive elements of the same category are reported only once, # on the first element of the group. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:206 def on_class(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:218 def on_sclass(class_node); end private @@ -8360,7 +8729,7 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # Autocorrect by moving the node, together with the contiguous group of # same-category elements that follows it, to its expected position. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:239 def autocorrect(corrector, node); end # A dynamic constant blocks every element: the cop does not move such constants, @@ -8368,22 +8737,22 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # A bare visibility modifier blocks only the elements whose meaning depends on # the visibility section they appear in. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:390 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:398 def barrier?(node, sibling); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:433 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:441 def begin_pos_with_comment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:456 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:464 def buffer; end # Setting categories hash allow you to group methods in group to match # in the {expected_order}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:468 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:476 def categories; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:301 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:309 def class_elements(class_node); end # Classifies a node to match with something in the {expected_order} @@ -8394,25 +8763,25 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # by method name # @return String otherwise trying to {humanize_node} of the current node # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:262 def classify(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:339 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:347 def dynamic_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:423 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:431 def end_position_for(node); end # Load expected order from `ExpectedOrder` config. # Define new terms in the expected order by adding new {categories}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:462 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:470 def expected_order; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:294 def find_category(name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:452 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:460 def find_heredoc(node); end # Categorize a node according to the {expected_order} @@ -8421,48 +8790,48 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # @param node to be analysed. # @return [String] with the key category or the `method_name` as string # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:273 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:281 def find_send_node_category(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:332 def flatten_class_elements(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:330 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:338 def humanize_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:325 def ignore?(node, classification); end # The expected position of the node: the first left sibling within its movable span # whose category is expected to appear after the node's. # Requiring a strictly later category keeps the order of elements sharing a category stable. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:350 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:358 def insertion_anchor(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:417 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:425 def marked_as_private_constant?(node, name); end # The node together with the contiguous same-category right siblings, # so that the whole group moves in a single pass while the offense is # reported only on its first element. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:363 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:371 def movable_group(node); end # Left siblings the node may be reordered with: those after the last barrier. # Ignored elements within the span are simply jumped over. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:379 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:387 def movable_span(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:222 def out_of_order_elements(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:407 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:415 def private_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:448 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:456 def start_line_position(node); end # Whether moving the node across a bare visibility modifier would change its meaning. @@ -8470,14 +8839,24 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # (e.g. `attr_accessor` when the expected order lists `private_attribute_macros`). # Inline visibility (`private def foo`, `def self.foo`) travels with the node. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:398 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:406 def visibility_dependent?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:300 def walk_over_nested_class_definition(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:444 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:452 def whole_line_comment_at_line?(line); end + + class << self + # A moved element is inserted before the line break that precedes its anchor. + # When the anchor follows a blank line, `Layout/EmptyLines`, + # `Layout/EmptyLinesAroundAccessModifier` or `Layout/EmptyLinesAroundClassBody` + # may remove that line break in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:195 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:182 @@ -8907,7 +9286,7 @@ class RuboCop::Cop::Layout::DefEndAlignment < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/def_end_alignment.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/layout/def_end_alignment.rb:67 def autocorrect(corrector, node); end end @@ -9435,42 +9814,45 @@ class RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition < ::RuboCop::Cop::B include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:84 def on_case(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:60 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:96 def on_rescue(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:75 def on_until(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:82 def on_until_post(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:70 def on_while(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:77 def on_while_post(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:136 def autocorrect(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:105 - def check_condition(condition); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:121 + def body_on_line?(body, line); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:109 + def check_condition(condition, body = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:129 def multiline_rescue_exceptions?(exception_nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:125 def multiline_when_condition?(when_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_line_after_multiline_condition.rb:117 def next_line_empty?(line); end end @@ -9715,13 +10097,16 @@ class RuboCop::Cop::Layout::EmptyLines < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:44 + def consecutive_blank_lines_possible?; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:48 def each_extra_empty_line(lines); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:66 def exceeds_line_offset?(line_diff); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines.rb:70 def previous_and_current_lines_empty?(line); end end @@ -10067,13 +10452,13 @@ class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop:: private - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:125 def allow_alias?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:135 def allow_alias_syntax?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:129 def attribute_or_allowed_method?(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:84 @@ -10088,7 +10473,7 @@ class RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor < ::RuboCop::Cop:: # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:102 def next_line_enable_directive_comment?(line); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:119 def next_line_node(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb:112 @@ -10195,63 +10580,69 @@ module RuboCop::Cop::Layout::EmptyLinesAroundBody include ::RuboCop::Cop::RangeHelp extend ::RuboCop::AST::NodePattern::Macros - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:20 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:22 def constant_definition?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:23 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:25 def empty_line_required?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:28 def check(node, body, adjusted_first_line: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:84 def check_beginning(style, first_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:70 def check_both(style, first_line, last_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:119 def check_deferred_empty_line(body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:46 def check_empty_lines_except_namespace(body, first_line, last_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:54 def check_empty_lines_special(body, first_line, last_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:88 def check_ending(style, last_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:101 def check_line(style, line, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:92 def check_source(style, line_no, desc); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:170 def deferred_message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:143 def first_child_requires_empty_line?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:151 def first_empty_line_required_child(body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:113 + def leading_dot_line?(line); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:166 def message(type, desc); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:133 def namespace?(body, with_one_child: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:159 def previous_line_ignoring_comments(send_line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:174 def valid_body_style?(body); end end +# pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:17 +RuboCop::Cop::Layout::EmptyLinesAroundBody::LEADING_DOT_TYPES = T.let(T.unsafe(nil), Set) + # pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:15 RuboCop::Cop::Layout::EmptyLinesAroundBody::MSG_DEFERRED = T.let(T.unsafe(nil), String) @@ -10437,22 +10828,28 @@ class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords < ::RuboCo # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:80 def check_body(body, line_of_def_or_kwbegin); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:116 def keyword_locations(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:142 def keyword_locations_in_ensure(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:138 def keyword_locations_in_rescue(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:99 def last_body_and_end_on_same_line?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:104 - def message(location, keyword); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:129 + def left_to_block_body_cop?(body, keyword_line); end # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:108 + def message(location, keyword); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:150 + def only_empty_lines_until_end?(body, keyword_line); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/empty_lines_around_exception_handling_keywords.rb:112 def style; end end @@ -10681,29 +11078,32 @@ class RuboCop::Cop::Layout::EndAlignment < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:175 def alignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:192 def alignment_node_for_variable_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:156 def asgn_variable_align_with(outer_node, inner_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:210 def assignment_or_operator_method(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:122 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:135 def check_asgn_alignment(outer_node, inner_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:126 def check_assignment(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:166 def check_other_alignment(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/end_alignment.rb:146 + def leading_node(rhs); end end # Checks for Windows-style line endings in the source code. @@ -10800,89 +11200,94 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:39 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:43 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:276 def align_column(asgn_token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:249 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:253 def align_equal_sign(corrector, token, align_to); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:243 def align_equal_signs(range, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:57 def aligned_locations(locs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:140 def aligned_on_other_column?(token, lines); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:108 def aligned_tok?(previous_token, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:265 def all_relevant_assignment_lines(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:281 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:285 def allow_for_trailing_comments?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:162 def build_group_profile(group); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:77 def check_assignment(token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:86 def check_other(token1, token2, ast); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:67 def check_tokens(ast, token1, token2); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:152 def distinct_spacings(entries); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:96 def extra_space_range(token1, token2); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:239 def force_equal_sign_alignment?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:156 def group_profile(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:213 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:217 def ignored_range?(ast, start_pos); end # Returns an array of ranges that should not be reported. It's the # extra spaces between the keys and values in a multiline hash, # since those are handled by the Layout/HashAlignment cop. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:224 def ignored_ranges(ast); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:187 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:191 def nearest_spacing_differs?(line_numbers, token, spacing); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:181 def nearest_spacing_varies?(previous_token, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:211 def prepare_alignment_data; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:171 def record_line_spacings(by_column, typed, line); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:203 def spacing_before_token_at(line_number, column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:118 def spacing_varies?(previous_token, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:133 def uniform_alignment_allowed?(token, lines, spacings); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:39 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/extra_spacing.rb:37 @@ -11039,7 +11444,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:257 def eligible_method_call?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:166 @@ -11053,59 +11458,59 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:321 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:322 def argument_alignment_applies?(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:175 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:213 def bare_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:233 def base_indentation(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:261 def base_range(send_node, arg_node); end # Returns the column of the given range. For single line ranges, this # is simple. For ranges with line breaks, we look a the last code line. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:273 def column_of(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:293 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:294 def comment_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:314 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:315 def conflicts_with_fixed_indentation_alignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:310 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:311 def enable_layout_first_method_argument_line_break?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:305 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:306 def enforce_first_argument_with_fixed_indentation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:203 def find_top_level_send(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:329 def indentation_of_method_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:197 def inner_call?(top_level_send); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:217 def message(arg_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:301 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:302 def on_new_investigation; end # Takes the line number of a given code line and returns a string # containing the previous line that's not a comment line or a blank # line. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:284 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:285 def previous_code_line(line_number); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:171 @@ -11114,7 +11519,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:188 def should_correct_entire_chain?(send_node, top_level_send); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:241 def special_inner_call_indentation?(node); end end @@ -11460,7 +11865,7 @@ class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base # Returns the description of what the correct indentation is based on. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:198 def base_description(indent_base_type); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:146 @@ -11475,13 +11880,13 @@ class RuboCop::Cop::Layout::FirstHashElementIndentation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:169 def check_right_brace(right_brace, first_pair, left_brace, left_parenthesis); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:234 def enforce_first_argument_with_fixed_indentation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:211 def message(base_description); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:217 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:219 def message_for_right_brace(indent_base_type); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_hash_element_indentation.rb:183 @@ -11620,19 +12025,27 @@ class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:100 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:84 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:101 def on_super(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:105 def ignore_last_element?; end + + class << self + # A line break inserted after `(` while `Style/MethodCallWithArgsParentheses` removes + # the parentheses in the same pass leaves the method name alone on its line. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:80 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_argument_line_break.rb:76 @@ -11693,16 +12106,21 @@ class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:66 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:69 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:73 def ignore_last_element?; end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:62 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_method_parameter_line_break.rb:60 @@ -11994,21 +12412,27 @@ class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:206 def on_yield(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:218 + def unalignable_styles; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:218 + def unalignable_styles=(_arg0); end + private - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:265 def add_offenses; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:371 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:375 def adjust(corrector, delta, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:311 def alignment_for(pair); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:313 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:325 def alignment_for_colons; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:309 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:321 def alignment_for_hash_rockets; end # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:234 @@ -12017,43 +12441,40 @@ class RuboCop::Cop::Layout::HashAlignment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:222 def autocorrect_incompatible_with_other_cops?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:285 def check_delta(delta, node:, alignment:); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:246 def check_pairs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:336 - def clamped_key_delta(key_delta, key); end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:340 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:344 def correct_key_value(corrector, delta, key, value, separator); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:332 - def correct_no_value(corrector, key_delta, key); end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:329 def correct_node(corrector, node, delta); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:384 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:388 def enforce_first_argument_with_fixed_indentation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:380 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:384 def good_alignment?(column_deltas); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:290 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:302 def ignore_hash_argument?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:353 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:298 + def key_out_of_line?(delta, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:357 def new_alignment(key); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:275 def register_offenses_with_format(offenses, format); end # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:240 def reset!; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:389 + # pkg:gem/rubocop#lib/rubocop/cop/layout/hash_alignment.rb:393 def same_line?(node1, node2); end end @@ -12123,10 +12544,10 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop:: private - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:187 def add_correct_closing_paren(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:274 def add_correct_external_trailing_comma(node, corrector); end # Autocorrection note: @@ -12161,81 +12582,81 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < ::RuboCop::Cop:: # Closing parenthesis helpers. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:165 def end_keyword_before_closing_parenthesis?(parenthesized_send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:223 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:225 def exist_argument_between_heredoc_end_and_closing_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:290 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:292 def external_trailing_comma?(node); end # Returns nil if no trailing external comma. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:295 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:297 def external_trailing_comma_offset_from_loc_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:140 def extract_heredoc(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:136 def extract_heredoc_argument(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:233 def find_most_bottom_of_heredoc_end(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:182 def fix_closing_parenthesis(node, corrector); end # External trailing comma helpers. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:269 def fix_external_trailing_comma(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:152 def heredoc_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:200 def incorrect_parenthesis_removal_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:216 def incorrect_parenthesis_removal_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:247 def internal_trailing_comma?(node); end # Returns nil if no trailing internal comma. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:252 def internal_trailing_comma_offset_from_last_arg(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:116 def outermost_send_on_same_line(heredoc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:191 def remove_incorrect_closing_paren(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:278 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:280 def remove_incorrect_external_trailing_comma(node, corrector); end # Internal trailing comma helpers. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:241 def remove_internal_trailing_comma(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:210 def safe_to_remove_line_containing_closing_paren?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:129 def send_missing_closing_parens?(parent, child, heredoc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:156 def single_line_send_with_heredoc_receiver?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:308 def space?(pos); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb:171 def subsequent_closing_parentheses_in_same_line?(outermost_send); end class << self @@ -12289,66 +12710,75 @@ class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:62 def on_heredoc(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:58 + def on_new_investigation; end + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:54 def squish_method?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:151 def adjust_heredoc_squish(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:161 def adjust_minus(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:156 def adjust_squiggly(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:185 def base_indent_level(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:196 def heredoc_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:200 def heredoc_end(node); end # Returns '~', '-' or nil # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:192 def heredoc_indent_type(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:204 def heredoc_squish?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:167 def indented_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:174 def indented_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:130 def line_too_long?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:143 def longest_line(lines); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:108 def message(heredoc_indent_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:104 + def offending_heredoc_bodies; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:83 def register_offense(node, heredoc_indent_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:118 def type_message(indentation_width, current_indent_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:147 def unlimited_heredoc_length?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:126 def width_message(indentation_width); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:100 + def within_offending_heredoc?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:49 @@ -12520,6 +12950,9 @@ RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String) # Checks that the indentation method is consistent. # Either tabs only or spaces only are used for indentation. # +# With `EnforcedStyle: tabs`, spaces that follow the indenting tabs are +# taken to be alignment rather than indentation, and are left alone. +# # @example EnforcedStyle: spaces (default) # # bad # # This example uses a tab to indent bar. @@ -12546,41 +12979,41 @@ RuboCop::Cop::Layout::IndentationConsistency::MSG = T.let(T.unsafe(nil), String) # bar # end # -# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:37 class RuboCop::Cop::Layout::IndentationStyle < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:45 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:61 def autocorrect(corrector, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:85 def autocorrect_lambda_for_spaces(corrector, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:80 def autocorrect_lambda_for_tabs(corrector, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:69 def find_offense(line, lineno); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:91 def in_string_literal?(ranges, tabs_range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:112 def message(_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:95 def string_literal_ranges(ast); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_style.rb:43 RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) # Checks for indentation that doesn't use the specified number of spaces. @@ -13239,31 +13672,34 @@ class RuboCop::Cop::Layout::LineContinuationSpacing < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:65 def find_offensive_spacing(line); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:126 def ignore_range?(backtick_range); end # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:91 def ignored_literal_ranges(ast); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:136 def ignored_parent?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:130 def ignored_ranges; end # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:49 def investigate(line, line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:120 def last_line(processed_source); end # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:73 def message(_range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:142 def no_space_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:114 + def output_record_separator_ranges(ast); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_continuation_spacing.rb:146 def space_style?; end end @@ -13349,21 +13785,30 @@ class RuboCop::Cop::Layout::LineEndStringConcatenationIndentation < ::RuboCop::C private - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:153 def add_offense_and_correction(node, message); end # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:109 def always_indented?(dstr_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:144 def base_column(child); end # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:113 - def check_aligned(children, start_index); end + def check_aligned(children, start_index, target_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:135 def check_indented(children); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:140 + def indented_column(children); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:128 + def register_misaligned_run(run, column_delta); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:124 + def same_column_runs(parts); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_end_string_concatenation_indentation.rb:103 def strings_concatenated_with_backslash?(dstr_node); end end @@ -13446,93 +13891,93 @@ class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:71 def max=(value); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:108 def on_array(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:91 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:111 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:113 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:120 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:101 def on_dstr(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:109 def on_hash(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:133 def on_investigation_end; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:95 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:122 def on_new_investigation; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:94 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:105 def on_potential_breakable_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:110 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:97 def on_str(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:418 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:458 def allow_string_split?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:481 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:521 def allowed_combination?(line, uri_range, qualified_name_range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:414 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:454 def allowed_heredoc; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:370 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:410 def allowed_line?(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:277 def breakable_block_range(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:493 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:533 def breakable_dstr?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:321 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:352 def breakable_dstr_begin_position(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:141 def breakable_range; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:141 def breakable_range=(_arg0); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:285 def breakable_range_after_semicolon(semicolon_token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:326 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:366 def breakable_range_by_line_index; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:308 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:326 def breakable_space_position(node, substr); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:268 def breakable_string?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:334 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:374 def breakable_string_delimiters; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:298 def breakable_string_position(node); end # Locate where to break a string that is too long, ensuring that escape characters @@ -13540,102 +13985,124 @@ class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base # If the string contains spaces, use them to determine a place for a clean break; # otherwise, the string will be broken at the line length limit. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:311 def breakable_string_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:448 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:337 + def breakable_string_range_at_limit(source_range); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:488 def check_directive_line(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:228 def check_for_breakable_block(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:253 def check_for_breakable_dstr(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:191 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:207 def check_for_breakable_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:220 def check_for_breakable_semicolons(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:223 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:241 def check_for_breakable_str(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:350 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:390 def check_line(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:465 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:505 def check_line_for_exemptions(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:195 def correct_endless_method_block_to_multiline(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:185 def correctable_endless_method_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:330 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:370 def endless_methods_by_line; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:398 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:333 + def escape_sequence_start(text); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:438 def excess_range(uri_range, line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:422 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:462 def extract_heredocs(ast); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:148 def handle_endless_method_line(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:338 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:378 def heredocs; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:342 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:382 def highlight_start(line); end # Find the largest possible substring of a string node to retain before a break # - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:509 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:549 def largest_possible_string(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:432 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:472 def line_in_permitted_heredoc?(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:409 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:449 def max; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:412 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:452 def max_line_length; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:475 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:360 + def opens_string?(begin_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:515 def range_if_applicable(line, type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:441 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:481 def receiver_contains_heredoc?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:161 def register_endless_method_offense(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:380 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:420 def register_offense(loc, line, line_index, length: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:172 def register_required_endless_method_offense(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:156 def require_endless_methods?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:376 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:416 def shebang?(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:315 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:346 def string_content_length(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:498 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:538 def string_delimiter(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:143 def track_endless_method(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:87 + def autocorrect_incompatible_with; end + end end +# A trailing backslash, or a trailing unicode, hex, octal, meta or control escape whose +# payload may be incomplete. An even run of backslashes is complete on its own. +# Meta and control prefixes chain (`\M-\C-x`, `\c\M-x`), so a whole chain is one escape, +# and a braced unicode escape may hold several space-separated codepoints. +# +# pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:79 +RuboCop::Cop::Layout::LineLength::ESCAPE_SEQUENCE_TAIL = T.let(T.unsafe(nil), Regexp) + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:73 RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String) @@ -13731,8 +14198,20 @@ class RuboCop::Cop::Layout::MultilineArrayBraceLayout < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineLiteralBraceLayout extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_array_brace_layout.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_array_brace_layout.rb:121 def on_array(node); end + + class << self + # Moving the closing bracket after a hash literal or method call element while + # `Layout/MultilineHashBraceLayout` or `Layout/MultilineMethodCallBraceLayout` moves + # that element's closing brace in the same pass places the bracket after whatever + # follows the moved brace, such as a comment. + # Moving it while `Style/ConcatArrayLiterals` removes the brackets in the same pass + # leaves the bracket behind. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_array_brace_layout.rb:115 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_array_brace_layout.rb:103 @@ -13944,46 +14423,55 @@ class RuboCop::Cop::Layout::MultilineBlockLayout < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:66 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:79 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:78 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:108 def add_offense_for_expression(node, expr, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:83 def args_on_beginning_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:115 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:130 def autocorrect_arguments(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:140 def autocorrect_body(corrector, node, block_body); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:152 def block_arg_string(node, args); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:100 def characters_needed_for_space_and_pipes(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:164 def include_trailing_comma?(args); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:87 def line_break_necessary_in_args?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:93 def needed_length_for_args(node); end + + class << self + # `Style/Lambda` moves the block arguments of `lambda` into `->(...)`, and + # `Style/ItBlockParameter` and `Style/HashEachMethods` remove some or all of them, + # in the same pass, while this cop moves them next to the block start. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:62 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_block_layout.rb:56 @@ -14087,8 +14575,17 @@ class RuboCop::Cop::Layout::MultilineHashBraceLayout < ::RuboCop::Cop::Base include ::RuboCop::Cop::MultilineLiteralBraceLayout extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:116 def on_hash(node); end + + class << self + # Moving the closing brace while `Style/HashAsLastArrayItem` or + # `Style/RedundantDoubleSplatHashBraces` removes the braces in the same pass leaves + # the brace behind. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:112 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_hash_brace_layout.rb:103 @@ -14349,22 +14846,30 @@ class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout < ::RuboCop::Cop::Bas include ::RuboCop::Cop::MultilineLiteralBraceLayout extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:118 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:115 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:122 def children(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:126 def ignored_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:130 def single_line_ignoring_receiver?(node); end + + class << self + # Moving the closing parenthesis and removing it under `omit_parentheses` in the same pass + # leaves the moved parenthesis behind. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:111 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_brace_layout.rb:103 @@ -14436,158 +14941,165 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Bas private - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:210 def after_multiline_block_base(first_call, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:299 def align_with_base_message(rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:238 def aligned_with_first_line_dot?(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:307 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:321 def alignment_base(node, rhs, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:366 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:380 def alignment_base_for_chained_receiver?(receiver_chain, base_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:102 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:289 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:303 def base_source; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:261 def calculate_column_delta_offense(rhs, correct_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:162 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:176 def check_hash_pair_indentation(node, lhs, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:167 def check_hash_pair_indented_style(rhs, pair_ancestor); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:248 def check_regular_indentation(node, lhs, rhs, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:117 def correct_block(corrector, block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:111 def correct_selector_only(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:266 def extra_indentation(given_style, parent); end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:69 def find_base_receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:411 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:425 def find_continuation_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:226 def find_enclosing_chain_call(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:354 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:368 def find_hash_method_base_in_receiver_chain(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:186 def find_hash_pair_alignment_base(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:405 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:419 def find_multiline_block_chain_node(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:75 def find_pair_ancestor(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:379 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:393 def first_call_alignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:445 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:459 def first_call_has_a_dot(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:194 def first_dot_alignment_base(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:396 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:410 def get_dot_right_above(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:435 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:449 def handle_descendant_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:234 def hash_arg_in_chain?(call, hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:159 def hash_pair_aligned?(pair_ancestor, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:163 def hash_pair_indented?(node, pair_ancestor, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:205 + # A block, `begin`, `if` or loop body is a separate set of statements, so + # a method chain in it is not the value of a hash pair the body is nested in. + # The send node of a block is still part of the value. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:91 + def inside_body?(ancestor, child); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:219 def inside_multiline_chain_arg?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:425 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:439 def leftmost_call_on_same_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:262 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:276 def message(node, lhs, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:390 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:404 def method_on_receiver_last_line?(node, base_receiver, type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:293 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:307 def no_base_message(lhs, rhs, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:139 def offending_range(node, lhs, rhs, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:452 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:466 def operation_rhs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:462 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:476 def operator_rhs?(node, receiver); end # a # .b # .c # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:346 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:360 def receiver_alignment_base(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:294 def relative_to_receiver_message(rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:123 def relevant_node?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:127 def right_hand_side(send_node); end # a.b # .c # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:334 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:348 def semantic_alignment_base(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:371 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:385 def semantic_alignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:290 def should_align_with_base?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:286 def should_indent_relative_to_receiver?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:435 def single_line_block_receiver?(receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:155 def skip_for_context?(node, pair_ancestor); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:316 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:330 def syntactic_alignment_base(lhs, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:98 def unwrap_block_node(node); end end @@ -14695,11 +15207,16 @@ class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout < ::RuboCop::Co include ::RuboCop::Cop::MultilineLiteralBraceLayout extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:125 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:128 def on_defs(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:121 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_definition_brace_layout.rb:115 @@ -15014,30 +15531,33 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:76 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:62 def on_lvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:57 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:66 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:118 def apply_reparse_correction(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:84 def check_assignment(node, _rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:206 def configured_to_not_be_inspected?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:225 def convertible_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:80 def end_with_percent_blank_string?(processed_source); end # Joining lines merges split string literals (`"a" \ "b"` into @@ -15046,28 +15566,34 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base # concatenation to a canonical form before comparing: nested # concatenations are flattened and adjacent literal parts merged. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:139 def fold_string_concatenation(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:200 def index_access_call_chained?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:154 + # Offenses registered in the same pass that share a line with `node` + # get joined onto that line too, so the combined line has to fit. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:109 + def joined_line_range(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:175 def merge_plain_strings(chunk); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:166 def merge_string_parts(parts); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:130 def normalize_reparsed_ast(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:189 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:213 def other_cop_takes_precedence?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:185 def plain_string?(node); end # Joining lines shifts the value of any later `__LINE__`, exactly as @@ -15075,22 +15601,22 @@ class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base # with an identifier, which stays valid in every position the keyword # can appear in. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:126 def preprocess_reparsed_source(source); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:90 def register_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:196 def require_backslash?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:221 def single_line_block_chain_enabled?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:156 def string_concatenation_parts(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:181 def stringish?(node); end end @@ -15118,79 +15644,88 @@ RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String) # # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:24 class RuboCop::Cop::Layout::RescueEnsureAlignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::EndKeywordAlignment extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:39 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:40 def on_ensure(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:44 def on_new_investigation; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:35 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:36 def on_resbody(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:199 def access_modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:177 def access_modifier_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:163 def aligned_with_leading_dot?(do_keyword_line, send_node_loc, rescue_keyword_column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:150 def aligned_with_line_break_method?(ancestor_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:195 + # A run of spaces sized to the target column would be turned back into tabs by + # `Layout/IndentationStyle`, generally landing on a different column, so under + # tabs the target line's own indentation is reused. There is nothing to reuse + # when the target does not start its line. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:100 + def alignment_indentation(location); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:208 def alignment_location(alignment_node); end # We will use ancestor or wrapper with access modifier. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:130 def alignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:108 def alignment_source(node, starting_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:146 def ancestor_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:169 def assignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:73 def autocorrect(corrector, node, alignment_location); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:224 def begin_end_alignment_style; end # Check alignment of node with rescue or ensure modifiers. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:57 def check(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:84 def format_message(alignment_node, alignment_loc, kw_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:186 def modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:192 def whitespace_range(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:33 +# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:34 RuboCop::Cop::Layout::RescueEnsureAlignment::ALTERNATIVE_ACCESS_MODIFIERS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:32 +# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:33 RuboCop::Cop::Layout::RescueEnsureAlignment::ANCESTOR_TYPES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:29 +# pkg:gem/rubocop#lib/rubocop/cop/layout/rescue_ensure_alignment.rb:30 RuboCop::Cop::Layout::RescueEnsureAlignment::MSG = T.let(T.unsafe(nil), String) # Checks if method calls are chained onto single line blocks. It considers that a @@ -15214,25 +15749,31 @@ class RuboCop::Cop::Layout::SingleLineBlockChain < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:36 + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:40 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:34 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:60 def call_method_after_block?(node, dot_range, closing_block_delimiter_line_num); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:40 + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:71 + def heredoc_opened_before?(receiver, range); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:44 def offending_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:66 def selector_range(node); end class << self - # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:28 + # `Style/FloatDivision` and `Style/NilComparison` rewrite a method chained to the block + # in the same pass, which must not start a line of its own. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/single_line_block_chain.rb:30 def autocorrect_incompatible_with; end end end @@ -15343,7 +15884,10 @@ class RuboCop::Cop::Layout::SpaceAfterNot < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_after_not.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_after_not.rb:38 + def unary_tilde?(receiver); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_after_not.rb:34 def whitespace_after_operator?(node); end end @@ -15385,7 +15929,8 @@ end # Checks the spacing inside and after block parameters pipes. Line breaks # inside parameter pipes are checked by `Layout/MultilineBlockLayout` and # not by this cop. Spaces inside a lambda's parameter parentheses are left -# to `Layout/SpaceInsideParens` when that cop enforces a conflicting style. +# to `Layout/SpaceInsideParens` when that cop is enabled, so the examples +# below apply to a lambda only when it is not. # # @example EnforcedStyleInsidePipes: no_space (default) # # bad @@ -15405,60 +15950,60 @@ end # {}.each { | x, y | puts x } # ->( x, y ) { puts x } # -# pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:28 +# pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:29 class RuboCop::Cop::Layout::SpaceAroundBlockParameters < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:34 def on_block(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:71 def check_after_closing_pipe(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:131 def check_arg(arg); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:109 def check_closing_pipe_space(arguments, closing_pipe); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:127 def check_each_arg(args); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:62 def check_inside_pipes(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:156 def check_no_space(space_begin_pos, space_end_pos, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:79 def check_no_space_style_inside_pipes(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:98 def check_opening_pipe_space(arguments, opening_pipe); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:142 def check_space(space_begin_pos, space_end_pos, range, msg, node = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:91 def check_space_style_inside_pipes(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:57 - def conflicting_space_inside_parens_style?(arguments); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:58 + def checked_by_space_inside_parens?(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:119 def last_end_pos_inside_pipes(arguments, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:46 def pipes(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:49 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:50 def pipes?(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_block_parameters.rb:54 def style_parameter_name; end end @@ -15650,18 +16195,21 @@ class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:253 def accept_left_parenthesis?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:257 def accept_left_square_bracket?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:251 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:261 def accept_namespace_operator?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:246 def accepted_opening_delimiter?(range, char); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:237 + def block_brace_with_no_space_style?(node, range); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:170 def check(node, locations, begin_keyword = T.unsafe(nil)); end @@ -15677,19 +16225,19 @@ class RuboCop::Cop::Layout::SpaceAroundKeyword < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:200 def do?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:269 def namespace_operator?(range, pos); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:263 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:273 def preceded_by_operator?(node, _range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:265 def safe_navigation_call?(range, pos); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:226 def space_after_missing?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_around_keyword.rb:219 def space_before_missing?(range); end end @@ -16037,49 +16585,53 @@ class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:59 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:83 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:82 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:137 def autocorrect(corrector, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:157 def block_delimiters_style; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:87 def check_empty(left_brace, space_plus_brace, used_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:113 def check_non_empty(left_brace, space_plus_brace, used_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:153 def conflict_with_block_delimiters?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:161 def empty_braces?(loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:105 def handle_different_styles_for_empty_braces(used_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:128 def space_detected(left_brace, space_plus_brace); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:121 def space_missing(left_brace); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:144 def style_for_empty_braces; end class << self - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:52 + # `Style/BlockDelimiters` decides whether to put a space before the `do` + # it writes by looking at the source before this cop removed the space, + # so the two corrections cannot be applied in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_before_block_braces.rb:55 def autocorrect_incompatible_with; end end end @@ -16375,13 +16927,20 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Ba # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:110 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:229 + # A closing bracket on its own line is only collapsed when the opening + # bracket ends up on the first element's line, so that the brackets + # stay symmetrical (see `Layout/MultilineArrayBraceLayout`). + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:220 + def closing_bracket_kept_apart?(node, tokens, left, right); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:242 def compact(corrector, bracket, side); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:215 - def compact_corrections(corrector, tokens, left, right); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:226 + def compact_corrections(corrector, node, tokens, left, right); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:209 def compact_offense(node, token, side: T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:174 @@ -16405,7 +16964,7 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Ba # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:152 def line_and_column_for(token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:198 def multi_dimensional_array?(tokens, token, side: T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:169 @@ -16414,7 +16973,7 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Ba # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:137 def next_to_newline?(tokens, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:190 def qualifies_for_compact?(tokens, token, side: T.unsafe(nil)); end end @@ -16557,7 +17116,10 @@ class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base def adjacent_braces(left_brace, right_brace); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:166 - def aligned_braces?(inner, right_brace, column); end + def aligned_braces?(inner, right_brace, column, left_brace); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:176 + def aligned_with_opening_brace_line?(left_brace, right_brace); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:135 def braces_with_contents_inside(node, inner); end @@ -16571,34 +17133,43 @@ class RuboCop::Cop::Layout::SpaceInsideBlockBraces < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:150 def check_right_brace(node, inner, left_brace, right_brace, single_line); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:246 + def closing_bracket_on_own_line?(inner); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:225 + def comment_at?(pos); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:172 def inner_last_space_count(inner); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:162 def multiline_block?(left_brace, right_brace); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:250 def no_space(begin_pos, end_pos, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:174 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:181 def no_space_inside_left_brace(left_brace, args_delimiter); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:266 def offense(begin_pos, end_pos, msg, style_param = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:211 def pipe?(args_delimiter); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:258 def space(begin_pos, end_pos, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:191 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:215 + def space_after_left_brace(left_brace); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:198 def space_inside_left_brace(left_brace, args_delimiter); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:229 def space_inside_right_brace(inner, right_brace, column); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:258 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_block_braces.rb:281 def style_for_empty_braces; end class << self @@ -17628,19 +18199,19 @@ class RuboCop::Cop::Lint::AmbiguousOperatorPrecedence < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:97 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:81 def greater_precedence?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:77 def operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:89 def operator_name(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_operator_precedence.rb:73 def precedence(node); end end @@ -20582,22 +21153,22 @@ class RuboCop::Cop::Lint::EmptyConditionalBody < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:86 def allow_comments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:132 def branch_range(node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:99 def can_simplify_conditional?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:140 def deletion_range(range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:128 def else_branch?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:120 def empty_if_branch?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:115 def flip_orphaned_else(corrector, node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/empty_conditional_body.rb:91 @@ -21916,16 +22487,16 @@ class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:176 def message(node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:45 def on_and(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:139 def on_case(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:156 def on_case_match(case_match_node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:69 @@ -21934,13 +22505,13 @@ class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:57 def on_or(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:170 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:108 def on_until(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:123 def on_until_post(node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:77 @@ -21951,37 +22522,43 @@ class RuboCop::Cop::Lint::LiteralAsCondition < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:206 def basic_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:238 def check_case(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:197 def check_for_literal(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:218 def check_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:247 def condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:249 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:262 def condition_evaluation?(node, cond); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:258 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:271 def correct_if_node(node, cond); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:215 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:228 def handle_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:201 + # Unwrapping the body of a loop that runs once would leave a `break`, + # `next` or `redo` that belongs to it outside of any loop. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:184 + def orphans_loop_control_keyword?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:214 def primitive_array?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:191 def void_value_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_as_condition.rb:255 def when_conditions_range(when_node); end end @@ -22075,60 +22652,82 @@ class RuboCop::Cop::Lint::LiteralInInterpolation < ::RuboCop::Cop::Base include ::RuboCop::Cop::PercentLiteral extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:28 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:27 def on_interpolation(begin_node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:57 def array_in_regexp?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:79 def autocorrected_value(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:153 def autocorrected_value_for_array(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:159 def autocorrected_value_for_hash(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:132 def autocorrected_value_for_string(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:142 def autocorrected_value_for_symbol(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:170 def autocorrected_value_in_hash(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:149 def autocorrected_value_in_hash_for_symbol(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:62 + def correctable_value(begin_node, final_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:201 def ends_heredoc_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:138 def escape_string_content(string); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:218 + def escape_trailing_hash_sign(begin_node, value); end + + # Each interpolation is checked against the original source, so correcting it in the + # same pass as a preceding one that leaves a `#` (or nothing) could join that `#` and + # a `{` from this one. It's left for the next iteration instead. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:232 + def follows_literal_interpolation?(begin_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:100 def handle_special_regexp_chars(begin_node, value); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:210 def in_array_percent_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:42 def offending?(node); end # Does node print its own source when converted to a string? # - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:190 def prints_as_self?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:240 + def replacement(node, expanded_value); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:195 def space_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:52 def special_keyword?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:121 + def starts_interpolation_after_hash_sign?(begin_node, value); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:225 + def unescaped_hash_sign?(text); end end # pkg:gem/rubocop#lib/rubocop/cop/lint/literal_in_interpolation.rb:25 @@ -22178,27 +22777,35 @@ RuboCop::Cop::Lint::LiteralInInterpolation::MSG = T.let(T.unsafe(nil), String) # # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:44 class RuboCop::Cop::Lint::Loop < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:55 def on_until_post(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:49 + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:51 def on_while_post(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:90 def build_break_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:76 + def insert_break_line(corrector, node, body); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:72 def keyword_and_condition_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:61 def register_offense(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:84 + def space_before_end(body); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:47 +# pkg:gem/rubocop#lib/rubocop/cop/lint/loop.rb:49 RuboCop::Cop::Lint::Loop::MSG = T.let(T.unsafe(nil), String) # Checks for magic comments placed where Ruby silently ignores them. @@ -22263,20 +22870,39 @@ class RuboCop::Cop::Lint::MisplacedMagicComment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:122 def check_encoding_comment(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:201 def check_magic_comment_above_shebang; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:158 def check_top_block_comment(comment, directive); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:152 + def comment_encoding(comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:235 + def comment_removal_range(comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:221 def comment_starts_line?(comment); end + # With an effective encoding comment already in place, moving another + # one in would override it. Drop an identical duplicate and leave a + # conflicting one for a human to resolve. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:142 + def correct_encoding_comment(corrector, comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:180 + def effective_encoding_comment; end + # First line that may carry an effective encoding comment. # # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:114 def effective_encoding_line; end + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:172 + def encoding_comment_moving_in?; end + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:118 def first_code_token; end @@ -22288,6 +22914,9 @@ class RuboCop::Cop::Lint::MisplacedMagicComment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:102 def known_encoding?(name); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:188 + def known_encoding_comment?(comment); end + # The Emacs and Vim regexps in `MagicComment` match anywhere inside a # comment, which would flag documentation that merely quotes a magic # comment (e.g. `# # -*- coding: UTF-8 -*-`). Require the magic @@ -22296,14 +22925,23 @@ class RuboCop::Cop::Lint::MisplacedMagicComment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:94 def magic_comment_shaped?(text); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:130 + def misplaced_encoding_position?(comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:225 def move_comment(corrector, comment, target_line); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:214 def preceded_only_by_magic_comments?(comment); end # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:109 def shebang?; end + + # Insert below an effective encoding comment rather than above it, + # which would push it off the only lines where Ruby honors it. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:197 + def top_block_insertion_line; end end # pkg:gem/rubocop#lib/rubocop/cop/lint/misplaced_magic_comment.rb:64 @@ -22361,23 +22999,33 @@ class RuboCop::Cop::Lint::MissingCopEnableDirective < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:99 def acceptable_range?(cop, line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:142 def department_enabled?(cop, comment); end # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:73 def each_missing_enable; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:111 def expected_open_range?(cop, line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:121 def max_range; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:125 def message(cop, comment, type = T.unsafe(nil)); end + + # A disable suspended by `enable-next` or `next +Cop` reopens below the + # statement, on a code line, so the comment that opened it has to come + # from the range rather than from its first line. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:92 + def opening_comment(line_range); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:84 + def statement_scoped?(line_range); end end # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_cop_enable_directive.rb:58 @@ -24145,28 +24793,28 @@ class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:434 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:445 def add_department_marker(department); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:335 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:346 def add_offense_for_cop_in_list(cop, range, ranges); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:294 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:305 def add_offense_for_entire_comment(comment, cops); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:325 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:336 def add_offense_for_some_cops(comment, cops); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:284 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:295 def add_offenses(redundant_cops); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:417 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:428 def all_cop_names; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:266 def all_disabled?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:344 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:355 def any_unknown_cop?(cops); end # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:69 @@ -24175,83 +24823,89 @@ class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:57 def cop_disabled_line_ranges; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:366 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:377 def cop_range(comment, cop); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:275 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:286 def department_disabled?(cop, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:426 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:437 def department_marker?(department); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:404 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:415 def describe(cop); end # A range opened by a `disable-next` directive starts at the statement, # not at the directive comment above it, so ask the range itself. # - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:161 def directive_comment(line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:291 def directive_count(comment); end # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:92 def directive_range_in_list(range, ranges); end + # A cop that only the `Preview` defaults disable runs again as soon as + # preview is turned off, so its directives are still needed. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:133 + def disabled_by_preview?(cop); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:61 def disabled_ranges; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:205 def each_already_disabled(cop, line_ranges); end # A next-statement directive with no statement attached (or misplaced # at the end of a code line) affects nothing, so it is redundant by # definition. # - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:172 def each_detached_next_directive; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:131 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:142 def each_line_range(cop, line_ranges); end # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:106 def each_redundant_disable(&block); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:432 def ends_its_line?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:278 def expected_final_disable?(cop, line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:238 def find_redundant_all(range, next_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:222 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:233 def find_redundant_cop(cop, range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:237 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:248 def find_redundant_department(cop, range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:183 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:194 def find_redundant_directive(cop, comment, line_range, next_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:254 def followed_ranges?(range, next_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:270 def ignore_offense?(line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:360 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:371 def leave_free_comment?(comment, range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:373 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:384 def matching_range(haystack, needle); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:413 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:424 def message(cop_names, enabling: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:348 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:359 def misplaced_next_directive?(comment); end # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:120 @@ -24260,25 +24914,25 @@ class RuboCop::Cop::Lint::RedundantCopDisableDirective < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:65 def previous_line_blank?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:258 def range_with_offense?(range, offenses = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:430 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:441 def remove_department_marker(department); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:313 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:324 def remove_entire_comment(corrector, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:155 def should_skip_line_range?(cop, line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:183 def skip_directive?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:384 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:395 def trailing_range?(ranges, range); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:354 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:365 def unknown_cop?(cop); end end @@ -24288,7 +24942,7 @@ RuboCop::Cop::Lint::RedundantCopDisableDirective::COP_NAME = T.let(T.unsafe(nil) # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:33 RuboCop::Cop::Lint::RedundantCopDisableDirective::DEPARTMENT_MARKER = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:392 +# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_cop_disable_directive.rb:403 RuboCop::Cop::Lint::RedundantCopDisableDirective::SIMILAR_COP_NAMES_CACHE = T.let(T.unsafe(nil), Hash) # removed. @@ -24409,14 +25063,18 @@ RuboCop::Cop::Lint::RedundantCopEnableDirective::MSG_ORPHAN_POP = T.let(T.unsafe # # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:30 class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:40 + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:41 def on_send(node); end private + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:71 + def autocorrect(corrector, dot, selector); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:56 def dir_glob?(receiver); end @@ -24427,13 +25085,13 @@ class RuboCop::Cop::Lint::RedundantDirGlobSort < ::RuboCop::Cop::Base def sort_with_comparator?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:38 +# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:39 RuboCop::Cop::Lint::RedundantDirGlobSort::GLOB_METHODS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:36 +# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:37 RuboCop::Cop::Lint::RedundantDirGlobSort::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:37 +# pkg:gem/rubocop#lib/rubocop/cop/lint/redundant_dir_glob_sort.rb:38 RuboCop::Cop::Lint::RedundantDirGlobSort::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for redundant quantifiers inside `Regexp` literals. @@ -27210,7 +27868,7 @@ class RuboCop::Cop::Lint::UnescapedBracketInRegexp < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:93 def detect_offenses(node, expr, skip_class_closer); end # When a character class opens with a bare `]` (e.g. `[^]]`), `regexp_parser` parses @@ -27218,14 +27876,25 @@ class RuboCop::Cop::Lint::UnescapedBracketInRegexp < ::RuboCop::Cop::Base # Ruby treats that `]` as the end of the class, not as an unescaped bracket, # so the first `]` following an empty set must be skipped. # - # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:76 def detect_offenses_in_tree(node, tree); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:89 def empty_character_set?(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:107 + # A double-quoted string turns `\]` into `]`, so its backslash needs escaping too. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:123 + def escaped_bracket(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:117 def range_at_index(node, index, offset); end + + # Offsets into the string's value only point at the right place in the source + # when the string has no escape sequences, so anything else is left alone. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:66 + def verbatim_string?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb:33 @@ -28569,7 +29238,7 @@ class RuboCop::Cop::Lint::UselessAssignment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_assignment.rb:81 def uncorrectable_assignment?(assignment_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_assignment.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_assignment.rb:227 def variable_in_loop_condition?(assignment_node, variable); end # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_assignment.rb:170 @@ -29451,9 +30120,6 @@ class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:122 - def check_expression(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:101 def on_begin(node); end @@ -29474,13 +30140,13 @@ class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:306 def all_keys_entirely_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:303 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:310 def all_values_entirely_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:277 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:284 def autocorrect_nonmutating_send(corrector, node, suggestion); end # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:266 @@ -29501,6 +30167,9 @@ class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:234 def check_ensure(node); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:122 + def check_expression(expr); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:140 def check_if_expression(if_node); end @@ -29525,7 +30194,7 @@ class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:157 def check_void_op(node, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:293 def entirely_literal?(node); end # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:242 @@ -29533,6 +30202,9 @@ class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:249 def setter_method?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:278 + def void_expression_range(node); end end # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:75 @@ -29979,24 +30651,27 @@ RuboCop::Cop::Metrics::BlockNesting::NESTING_BLOCKS = T.let(T.unsafe(nil), Array class RuboCop::Cop::Metrics::ClassLength < ::RuboCop::Cop::Base include ::RuboCop::Cop::CodeLength - # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:55 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:45 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:47 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:49 def on_sclass(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:67 - def find_expression_within_parent(parent); end + # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:65 + def cop_label; end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:63 - def message(length, max_length); end + # pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:69 + def find_expression_within_parent(parent); end end +# pkg:gem/rubocop#lib/rubocop/cop/metrics/class_length.rb:43 +RuboCop::Cop::Metrics::ClassLength::LABEL = T.let(T.unsafe(nil), String) + # Checks for literals with extremely many entries. This is indicative of # configuration or data that may be better extracted somewhere else, like # a database, fetched from an API, or read from a non-code file (CSV, @@ -30112,9 +30787,6 @@ class RuboCop::Cop::Metrics::CyclomaticComplexity < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/metrics/cyclomatic_complexity.rb:45 def complexity_score_for(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/metrics/cyclomatic_complexity.rb:52 - def count_block?(block); end end # pkg:gem/rubocop#lib/rubocop/cop/metrics/cyclomatic_complexity.rb:40 @@ -30229,21 +30901,24 @@ RuboCop::Cop::Metrics::MethodLength::LABEL = T.let(T.unsafe(nil), String) class RuboCop::Cop::Metrics::ModuleLength < ::RuboCop::Cop::Base include ::RuboCop::Cop::CodeLength - # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:52 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:54 def module_definition?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:47 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:41 + # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:43 def on_module(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:56 - def message(length, max_length); end + # pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:58 + def cop_label; end end +# pkg:gem/rubocop#lib/rubocop/cop/metrics/module_length.rb:41 +RuboCop::Cop::Metrics::ModuleLength::LABEL = T.let(T.unsafe(nil), String) + # Checks for methods with too many parameters. # # The maximum number of parameters is configurable. @@ -30430,14 +31105,11 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator include ::RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:34 - def initialize(node, discount_repeated_attributes: T.unsafe(nil)); end + def initialize(node); end # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:42 def calculate; end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:76 - def calculate_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:65 def else_branch?(node); end @@ -30458,6 +31130,9 @@ class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:124 def branch?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:76 + def calculate_node(node); end + # pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/abc_size_calculator.rb:120 def capturing_variable?(name); end @@ -30815,11 +31490,14 @@ end module RuboCop::Cop::MultilineElementLineBreaks private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:23 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:25 def all_on_same_line?(nodes, ignore_last: T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:10 def check_line_breaks(_node, children, ignore_last: T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_element_line_breaks.rb:33 + def heredoc_opened_before?(previous_children, child); end end # Common functionality for checking multiline method calls and binary @@ -31013,37 +31691,40 @@ module RuboCop::Cop::MultilineLiteralBraceLayout private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:35 def check(node); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:12 def check_brace_layout(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:43 def check_new_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:51 def check_same_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:59 def check_symmetrical(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:87 def children(node); end # This method depends on the fact that we have guarded # against implicit and empty literals. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:99 def closing_brace_on_same_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:75 def empty_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:141 + def heredoc_opened_on_closing_brace_line?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:83 def ignored_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:79 def implicit_literal?(node); end # Starting with the parent node and recursively for the parent node's @@ -31071,7 +31752,7 @@ module RuboCop::Cop::MultilineLiteralBraceLayout # EOM # ) # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:127 def last_line_heredoc?(node, parent = T.unsafe(nil)); end # Returns true for the case @@ -31079,13 +31760,13 @@ module RuboCop::Cop::MultilineLiteralBraceLayout # b # comment # ].some_method # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:27 def new_line_needed_before_closing_brace?(node); end # This method depends on the fact that we have guarded # against implicit and empty literals. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/multiline_literal_brace_layout.rb:93 def opening_brace_on_same_line?(node); end end @@ -31156,13 +31837,6 @@ class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:62 def message(node); end - # When `AllCops/UseProjectIndex` is enabled, methods that override a - # method defined by an ancestor elsewhere in the project are not - # reported: renaming an override breaks the inherited contract. - # - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:87 - def overrides_inherited_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:70 def proper_attribute_name?(node); end end @@ -31684,9 +32358,12 @@ class RuboCop::Cop::Naming::HeredocDelimiterCase < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_case.rb:54 def correct_case_delimiters?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_case.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_case.rb:65 def correct_delimiters(source); end + # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_case.rb:59 + def corrected_delimiter_in_body?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_case.rb:50 def message(_node); end end @@ -31724,7 +32401,10 @@ class RuboCop::Cop::Naming::HeredocDelimiterNaming < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:49 + def forbidden_delimiter_regexps; end + + # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:53 def forbidden_delimiters; end # pkg:gem/rubocop#lib/rubocop/cop/naming/heredoc_delimiter_naming.rb:41 @@ -32687,55 +33367,48 @@ class RuboCop::Cop::Naming::PredicatePrefix < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:113 def dynamic_method_define(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:145 - def offending_prefixes_for(node, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:132 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:145 def on_defs(node); end # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:119 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:167 def sorbet_return_type(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:147 def validate_config; end private - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:176 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:177 def allowed_method_name?(method_name, prefix); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:185 def expected_name(method_name, prefix); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:199 def forbidden_prefixes; end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:195 def message(method_name, new_name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:211 def method_definition_macro?(macro_name); end - # When `AllCops/UseProjectIndex` is enabled, methods that override a - # method defined by an ancestor elsewhere in the project are not - # reported: renaming an override breaks the inherited contract. - # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:217 - def overrides_inherited_method?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:159 + def offending_prefixes_for(node, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:203 def predicate_prefixes; end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:171 def sorbet_sig?(node, return_type: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:207 def use_sorbet_sigs?; end end @@ -33145,8 +33818,8 @@ class RuboCop::Cop::Offense # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:100 - def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil), justification: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:136 + def initialize(severity, location, message, cop_name, status = T.unsafe(nil), corrector = T.unsafe(nil), justification: T.unsafe(nil), corrections: T.unsafe(nil), correction_safe: T.unsafe(nil)); end # @api public # @@ -33156,7 +33829,7 @@ class RuboCop::Cop::Offense # @return [Integer] # comparison result # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:315 def <=>(other); end # @api public @@ -33164,22 +33837,22 @@ class RuboCop::Cop::Offense # @return [Boolean] # returns `true` if two offenses contain same attributes # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:253 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:296 def ==(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:237 def column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:245 def column_length; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:269 def column_range; end # @api public @@ -33205,7 +33878,7 @@ class RuboCop::Cop::Offense # An offense suppressed by a directive comment is not correctable - # autocorrect will not touch it. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:180 def correctable?; end # @api public @@ -33216,7 +33889,7 @@ class RuboCop::Cop::Offense # whether this offense is automatically corrected via # autocorrect or a todo. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:191 def corrected?; end # @api public @@ -33226,9 +33899,35 @@ class RuboCop::Cop::Offense # @return [Boolean] # whether this offense is automatically disabled via a todo. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:201 def corrected_with_todo?; end + # @api public + # + # @!attribute [r] correction_safe + # + # @return [Boolean] + # whether autocorrection would apply {#corrections} in a normal `-a` + # run. A cop marked `Safe: false` or `SafeAutoCorrect: false` still + # builds its correction, but only `-A` applies it, so a consumer that + # applies edits itself has to make the same distinction. + # + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:122 + def correction_safe; end + + # @api public + # + # @!attribute [r] corrections + # + # @return [Array] + # the individual edits that autocorrecting this offense would make, in + # source order. Empty when the offense has no correction. Unlike + # {#corrector}, this survives serialization, so it is available on a + # cache hit and in parallel runs. + # + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:111 + def corrections; end + # @api public # # @!attribute [r] corrector @@ -33247,18 +33946,18 @@ class RuboCop::Cop::Offense # whether this offense was locally disabled with a # disable or todo where it occurred. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:212 def disabled?; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:302 def eql?(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:254 def first_line; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:304 def hash; end # @api public @@ -33266,7 +33965,7 @@ class RuboCop::Cop::Offense # @return [Parser::Source::Range] # the range of the code that is highlighted # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:220 def highlighted_area; end # @api public @@ -33278,22 +33977,22 @@ class RuboCop::Cop::Offense # (the text after `--`), or `nil` when the offense is not suppressed # or the directive carries no reason # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:100 def justification; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:264 def last_column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:259 def last_line; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:191 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:234 def line; end # @api public @@ -33309,10 +34008,10 @@ class RuboCop::Cop::Offense # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:28 def location; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:157 def marshal_dump; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:162 def marshal_load(array); end # @api public @@ -33334,7 +34033,7 @@ class RuboCop::Cop::Offense # outputting column numbers, we want them to start at 1. One # reason is that editors, such as Emacs, expect this. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:278 def real_column; end # @api private @@ -33344,7 +34043,7 @@ class RuboCop::Cop::Offense # because the 0-based end-exclusive column is the same as the 1-based # column of the last character. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:288 def real_last_column; end # @api public @@ -33358,7 +34057,7 @@ class RuboCop::Cop::Offense # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:240 def source_line; end # @api private @@ -33369,8 +34068,17 @@ class RuboCop::Cop::Offense # @api private # This is just for debugging purpose. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:227 def to_s; end + + private + + # Extracted eagerly rather than on demand because the offense is frozen, + # and because a corrector cannot be serialized - the cache and parallel + # workers would otherwise hand back offenses that have lost their edits. + # + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:328 + def corrections_from(corrector); end end # @api private @@ -33378,6 +34086,56 @@ end # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:10 RuboCop::Cop::Offense::COMPARISON_ATTRIBUTES = T.let(T.unsafe(nil), Array) +# A single edit of an autocorrection: the source range it replaces and +# the text it replaces it with. An insertion has an empty range, a +# removal an empty replacement. +# +# @api public +# +# pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 +class RuboCop::Cop::Offense::Correction < ::Struct + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def begin_pos; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def begin_pos=(_); end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def end_pos; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def end_pos=(_); end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:130 + def length; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def replacement; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def replacement=(_); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def [](*_arg0); end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def inspect; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def keyword_init?; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def members; end + + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:129 + def new(*_arg0); end + end +end + +# pkg:gem/rubocop#lib/rubocop/cop/offense.rb:89 +RuboCop::Cop::Offense::EMPTY_CORRECTIONS = T.let(T.unsafe(nil), Array) + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:87 RuboCop::Cop::Offense::NO_LOCATION = T.let(T.unsafe(nil), RuboCop::Cop::Offense::PseudoSourceRange) @@ -33539,56 +34297,84 @@ class RuboCop::Cop::ParenthesesCorrector # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:12 def correct(corrector, node); end + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:24 + def heredoc_strands_code_after_close_paren?(node); end + private # Add a comma back after the heredoc identifier # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:145 def add_heredoc_comma(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:48 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:89 def chained_after_close_paren?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:75 def comment_above_close_paren_swallows_chain?(node, buffer); end # If the node contains a heredoc, remove the comma too # It'll be added back in the right place later # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:135 def extend_range_for_heredoc(node, range); end # If removing parentheses leaves a comma on its own line, remove all the whitespace # preceding it to prevent a syntax error. # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:112 def handle_orphaned_comma(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:151 def heredoc?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:53 + def heredoc_above_close_paren_swallows_chain?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:59 + def heredoc_body_before_close_paren?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:99 def next_char_is_question_mark?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:103 def only_closing_paren_before_comma?(node); end # Get a range for the closing parenthesis and all whitespace to the left of it # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:122 def parens_range(node); end # When the line above `)` ends with a comment and a chained call follows `)`, # crossing the newline would pull the chain into the comment. Preserve the newline. + # When a heredoc body comes before `)`, a chained call has to start on the line + # after the terminator instead, since the terminator must stay alone on its line. # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:28 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:38 def remove_close_paren(corrector, node, buffer); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:95 def ternary_condition?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/parentheses_corrector.rb:69 + def text_after_close_paren(node); end end end +# Common functionality for checking whether a node is used in a pattern of +# pattern matching, where only some expressions are allowed. +# +# pkg:gem/rubocop#lib/rubocop/cop/mixin/pattern_matching_help.rb:7 +module RuboCop::Cop::PatternMatchingHelp + private + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/pattern_matching_help.rb:15 + def in_pattern?(node); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/mixin/pattern_matching_help.rb:8 +RuboCop::Cop::PatternMatchingHelp::PATTERN_TYPES = T.let(T.unsafe(nil), Array) + # Common functionality for handling percent arrays. # # pkg:gem/rubocop#lib/rubocop/cop/mixin/percent_array.rb:6 @@ -33808,10 +34594,10 @@ module RuboCop::Cop::PrecedingFollowingAlignment # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:102 def aligned_words?(range, line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:213 def alignment_line_ranges(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:204 def alignment_lines(line_number); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:15 @@ -33823,19 +34609,22 @@ module RuboCop::Cop::PrecedingFollowingAlignment # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:164 def assignment_tokens; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:226 def definition_boundary_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:279 + def first_operator_on_line(line); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:195 def interrupting_operator_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:189 def relevant_assignment_lines(line_range); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:236 def relevant_lines(line_range, boundary_lines = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/preceding_following_alignment.rb:265 def remove_equals_in_def(asgn_tokens, processed_source); end end @@ -33892,7 +34681,7 @@ module RuboCop::Cop::ProjectIndexHelp private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:185 def compute_project_index_signature; end # Returns the definitions among `definitions` that live in a file other than the @@ -33910,7 +34699,7 @@ module RuboCop::Cop::ProjectIndexHelp # affect the singleton class; pass `ignore_extend: true` when reasoning # about instance-side ancestry only. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:144 def fully_resolved_index_ancestry?(declaration, ignore_extend: T.unsafe(nil)); end # A namespace without any singleton method has no singleton-class @@ -33940,10 +34729,16 @@ module RuboCop::Cop::ProjectIndexHelp # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:82 def lexical_nesting_of(node); end + # Whether the `def`/`defs` node overrides a method defined by an ancestor + # of its enclosing class or module elsewhere in the project. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:124 + def overrides_inherited_method?(def_node); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:53 def prior_definition_in_other_file(definitions); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:176 def project_index_signature; end # Resolves a constant node the way Ruby does: the first segment through @@ -33957,13 +34752,13 @@ module RuboCop::Cop::ProjectIndexHelp # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:64 def resolve_constant_in_index(const_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:159 def resolved_mixin_references?(definition, ignore_extend: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:153 def resolved_superclass_reference?(definition); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:169 def same_file?(path, other); end class << self @@ -34418,29 +35213,29 @@ module RuboCop::Cop::ReparsedEquivalence # corrected fragment can be cut out of the corrected source by adjusting # for the edits' length delta. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:149 def corrected_scope_fragment(scope, corrected); end # Whether the exact correction for `item` produces source that still # parses, without requiring an equivalent AST. For corrections that # intentionally change the tree. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:76 def correction_parses?(item); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:131 def corrections_verify?(scope, items); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:103 def item_range(item); end # Hook: loosen strict tree equality for corrections that are # equivalence-preserving beyond parse identity. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:87 def normalize_reparsed_ast(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:169 def normalized_original(original_source, original_ast); end # Both sides are parsed with the original path so that `__FILE__` @@ -34449,12 +35244,12 @@ module RuboCop::Cop::ReparsedEquivalence # `__LINE__`, whose values would otherwise differ from a fragment parsed # at a different line offset. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:161 def parses_equivalently?(original_source, original_ast, corrected_source); end # Hook: rewrite both sides before parsing. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:92 def preprocess_reparsed_source(source); end # The innermost scope that both contains `range` and parses standalone. @@ -34463,13 +35258,13 @@ module RuboCop::Cop::ReparsedEquivalence # statements do not qualify, since an outer local would reparse as a # method call. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:112 def reparse_scope(range); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:96 def scope_groups(items); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:126 def verification_too_large?(scope); end # Returns the items whose corrections are verified. `oversized` controls @@ -34480,6 +35275,13 @@ module RuboCop::Cop::ReparsedEquivalence # # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:52 def verified_by_reparse(items, oversized: T.unsafe(nil)); end + + # Verifies a group with a single reparse and bisects it when that fails, + # so a few significant items among many cost a logarithmic number of + # reparses rather than one each. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:65 + def verified_subset(scope, group); end end # Above this size, verification does not reparse. What happens to such @@ -34753,6 +35555,13 @@ RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array # passing the `create_additions` keyword argument emits a deprecation warning, with the # goal of being secure by default in the next major version 3.0.0. # +# NOTE: Before `json` gem version 2.17.0, `JSON.load` only takes options as its third +# argument. A hash passed as the second argument is taken as the `proc` argument, so +# its `create_additions` option is ignored. Which `json` version runs can't be told +# statically (the lockfile may resolve a newer one than the default gem loaded in +# production), so options passed as the second argument are always reported. Pass +# `nil` as the second argument instead. +# # @safety # This cop's autocorrection is unsafe because it's potentially dangerous. # If using a stream, like `JSON.load(open('file'))`, you will need to call @@ -34764,29 +35573,32 @@ RuboCop::Cop::Security::IoMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array # JSON.load('{}') # JSON.restore('{}') # +# # bad - ignored by `json` older than 2.17.0 +# JSON.load('{}', create_additions: false) +# # # good # JSON.parse('{}') # JSON.unsafe_load('{}') # # # good - explicit use of `create_additions` option -# JSON.load('{}', create_additions: true) -# JSON.load('{}', create_additions: false) +# JSON.load('{}', nil, create_additions: true) +# JSON.load('{}', nil, create_additions: false) # -# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:44 +# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:54 class RuboCop::Cop::Security::JSONLoad < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:61 def insecure_json_load(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:71 def on_send(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:47 +# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:57 RuboCop::Cop::Security::JSONLoad::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:48 +# pkg:gem/rubocop#lib/rubocop/cop/security/json_load.rb:58 RuboCop::Cop::Security::JSONLoad::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for the use of Marshal class methods which have @@ -35101,16 +35913,16 @@ module RuboCop::Cop::StatementModifier # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:87 def allowed_patterns; end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:141 def code_after(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:165 def comment_disables_cop?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:133 def first_line_comment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:100 def if_body_source(if_body); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:48 @@ -35119,7 +35931,7 @@ module RuboCop::Cop::StatementModifier # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:81 def line_length_enabled_at_line?(line); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:119 def method_source(if_body); end # The rendered modifier form is compared against the bare maximum, not @@ -35139,17 +35951,23 @@ module RuboCop::Cop::StatementModifier # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:20 def non_eligible_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:113 def omitted_value_in_last_hash_arg?(if_body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:147 def parenthesize?(node); end # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:12 def single_line_as_modifier?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:159 + def ternary_branch_or_endless_method_body?(parent); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:92 def to_modifier_form(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:125 + def wrapped_value(if_body); end end # Classes that include this module just implement functions to determine @@ -35361,79 +36179,85 @@ class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:263 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:270 def access_modifier_is_inlined?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:274 def access_modifier_is_not_inlined?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:241 def allow_modifiers_on_alias_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:237 def allow_modifiers_on_attrs?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:233 def allow_modifiers_on_symbols?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:187 def allowed?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:195 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:202 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:211 def autocorrect_group_style(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:218 def autocorrect_inline_style(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:255 def correctable_group_offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:368 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:375 def def_source(node, def_nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:310 + # `private(*names)` with a list computed at runtime names no definition + # the modifier could be grouped with. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:198 + def dynamic_method_list?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:317 def find_argument_less_modifier_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:291 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:298 def find_corresponding_def_nodes(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:359 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:366 def first_comment_or_node_start(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:262 def group_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:266 def inline_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:339 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:346 def insert_inline_modifier(corrector, node, modifier_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:281 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:288 def message(range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:245 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:222 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:229 def percent_symbol_array?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:349 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:356 def remove_modifier_node_within_begin(corrector, modifier_node, begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:343 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:350 def remove_nodes(corrector, *nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:331 def replace_defs(corrector, node, def_nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:278 def right_siblings_same_inline_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:318 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:325 def select_grouped_def_nodes(node); end end @@ -35638,16 +36462,22 @@ class RuboCop::Cop::Style::Alias < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:137 def bareword?(sym_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:177 + def bareword_for(sym_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:141 + def bareword_symbol?(sym_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:150 def correct_alias_method_to_alias(corrector, send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:157 def correct_alias_to_alias_method(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:164 def correct_alias_with_symbol_args(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:169 def identifier(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/alias.rb:126 @@ -35710,12 +36540,15 @@ class RuboCop::Cop::Style::AmbiguousEndlessMethodDefinition < ::RuboCop::Cop::Ba # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:48 def on_def(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:60 + def on_defs(node); end + private - # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:70 def keyword(operation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/ambiguous_endless_method_definition.rb:64 def modifier_form?(operation); end end @@ -35767,25 +36600,25 @@ class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:55 def on_and(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:60 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:58 def on_or(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:65 def on_until(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:66 def on_until_post(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:63 def on_while(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:64 def on_while_post(node); end private @@ -35795,35 +36628,40 @@ class RuboCop::Cop::Style::AndOr < ::RuboCop::Cop::Base # recurse down a level and add parens to 'obj.method arg' # however, 'not x' also parses as (send x :!) # - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:121 def correct_not(node, receiver, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:133 def correct_other(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:99 def correct_send(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:112 def correct_setter(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:148 def correctable_send?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:140 def keep_operator_precedence(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:95 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:89 def on_conditionals(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:70 def process_logical_operator(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:152 def whitespace_before_arg(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:51 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/and_or.rb:49 @@ -36014,7 +36852,7 @@ class RuboCop::Cop::Style::ArgumentsForwarding < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:263 def classify_send_nodes(def_node, send_nodes, referenced_lvars, forwardable_args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:573 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:576 def explicit_block_name?; end # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:183 @@ -36073,99 +36911,99 @@ RuboCop::Cop::Style::ArgumentsForwarding::KWARGS_MSG = T.let(T.unsafe(nil), Stri # Classifies send nodes for possible rest/kwrest/all (including block) forwarding. # -# pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:385 +# pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:386 class RuboCop::Cop::Style::ArgumentsForwarding::SendNodeClassifier extend ::RuboCop::AST::NodePattern::Macros - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:414 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:415 def initialize(def_node, send_node, referenced_lvars, forwardable_args, **config); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:460 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:461 def classification; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:398 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:399 def def_all_anonymous_args?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:392 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:393 def extract_forwarded_kwrest_arg(param0 = T.unsafe(nil), param1); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:448 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:449 def forwarded_block_arg; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:395 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:396 def forwarded_block_arg?(param0 = T.unsafe(nil), param1); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:436 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:437 def forwarded_kwrest_arg; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:424 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:425 def forwarded_rest_arg; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:389 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:390 def forwarded_rest_arg?(param0 = T.unsafe(nil), param1); end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:407 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:408 def send_all_anonymous_args?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:544 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:547 def additional_kwargs?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:540 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:543 def additional_kwargs_or_forwarded_kwargs?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:554 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:557 def allow_offense_for_no_block?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:525 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:528 def any_arg_referenced?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:509 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:512 def arguments; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:475 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:476 def can_forward_all?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:548 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:551 def forward_additional_kwargs?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:505 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:508 def forwarded_rest_and_kwrest_args; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:567 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:570 def missing_rest_arg_or_kwrest_arg?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:558 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:561 def no_additional_args?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:533 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:536 def no_post_splat_args?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:501 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:502 def offensive_block_forwarding?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:521 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:524 def referenced_block_arg?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:517 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:520 def referenced_kwrest_arg?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:513 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:516 def referenced_rest_arg?; end # def foo(a = 41, ...) is a syntax error in 3.0. # - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:486 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:487 def ruby_30_or_lower_optarg?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:490 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:491 def ruby_32_only_anonymous_forwarding?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:497 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:498 def ruby_32_or_higher_missing_rest_or_kwest?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:529 + # pkg:gem/rubocop#lib/rubocop/cop/style/arguments_forwarding.rb:532 def target_ruby_version; end end @@ -36562,7 +37400,7 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:76 def class_eval?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:27 @@ -36579,10 +37417,10 @@ class RuboCop::Cop::Style::Attr < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:46 def define_attr_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:61 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/attr.rb:65 def replacement_method(node); end end @@ -36861,12 +37699,12 @@ class RuboCop::Cop::Style::BitwisePredicate < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/bitwise_predicate.rb:60 def nobits?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/bitwise_predicate.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/bitwise_predicate.rb:76 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/bitwise_predicate.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/bitwise_predicate.rb:96 def preferred_method(node); end end @@ -37084,131 +37922,149 @@ class RuboCop::Cop::Style::BlockDelimiters < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:202 def on_block(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:198 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:214 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:213 def on_numblock(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:183 def on_send(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:199 + def on_super(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:200 + def on_yield(node); end + private - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:489 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:505 def array_or_range?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:218 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:493 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:519 def begin_required?(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:244 def braces_for_chaining_message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:432 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:439 def braces_for_chaining_style?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:256 def braces_required_message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:409 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:416 def braces_required_method?(method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:413 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:420 def braces_required_methods; end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:440 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:404 + def collection_of_for_loop?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:447 def correction_would_break_code?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:330 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:332 def end_of_chain(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:454 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:470 def functional_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:446 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:462 def functional_method?(method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:450 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:466 def functional_methods; end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:348 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:350 def get_blocks(node, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:417 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:424 def line_count_based_block_style?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:228 def line_count_based_message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:258 + # A `do` in the condition of `while` or `until` is taken as the start of + # the loop body. Inside the body of another block it is unambiguous again. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:455 + def loop_condition?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:260 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:401 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:408 def modifier_rescue?(rescue_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:308 def move_comment_before_block(corrector, comment, block_node, closing_brace); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:462 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:478 def procedural_method?(method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:466 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:482 def procedural_methods; end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:458 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:474 def procedural_oneliners_may_have_braces?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:373 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:375 def proper_block_style?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:337 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:339 def remove_trailing_whitespace(corrector, range, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:269 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:271 def replace_braces_with_do_end(corrector, loc); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:287 def replace_do_end_with_braces(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:388 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:391 def require_do_end?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:482 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:498 def return_value_of_scope?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:470 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:486 def return_value_used?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:428 def semantic_block_style?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:236 def semantic_message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:499 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:525 def single_argument_operator_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:322 def source_range_before_comment(range, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:304 def whitespace_after?(range, length = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:298 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:300 def whitespace_before?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:343 + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:345 def with_block?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:509 + def wrap_body_with_begin(corrector, body); end + class << self # pkg:gem/rubocop#lib/rubocop/cop/style/block_delimiters.rb:179 def autocorrect_incompatible_with; end @@ -37223,27 +38079,27 @@ RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(n # Corrector to correct conditional assignment in `case` statements. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:632 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:636 class RuboCop::Cop::Style::CaseCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:637 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:641 def correct(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:647 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:651 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:667 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:671 def extract_branches(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:661 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:665 def extract_tail_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:677 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:681 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -37387,72 +38243,77 @@ class RuboCop::Cop::Style::CaseLikeIf < ::RuboCop::Cop::Base include ::RuboCop::Cop::MinBranchesCount extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:61 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:85 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:230 def branch_conditions(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:244 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:247 def class_reference?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:169 def collect_conditions(node, target, conditions); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:215 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:219 def condition_from_binary_op(lhs, rhs, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:203 def condition_from_equality_node(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:212 def condition_from_include_or_cover_node(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:208 def condition_from_match_node(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:188 def condition_from_send_node(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:238 def const_reference?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:253 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:256 def correction_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:251 def deparenthesize(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:106 def find_target(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:139 def find_target_in_equality_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:151 def find_target_in_include_or_cover_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:157 def find_target_in_match_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:124 def find_target_in_send_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:269 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:272 def regexp_with_named_captures?(node); end # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides) # - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:258 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:261 def regexp_with_working_captures?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:100 def should_check?(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:57 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/case_like_if.rb:55 @@ -37565,42 +38426,42 @@ class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:74 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:80 def on_module(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:145 def add_trailing_end(corrector, node, padding); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:275 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:313 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:302 def check_compact_style(node, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:293 def check_nested_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:237 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:275 def check_style(node, body, style); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:150 def compact_definition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:201 def compact_identifier_name(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:186 def compact_node(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:323 def compact_node_name?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:191 def compact_replacement(node); end # Compacting removes this definition of the namespace, so the result raises @@ -37608,61 +38469,81 @@ class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base # With the project index this is verified before correcting; without it the # correction is performed regardless (the cop's autocorrection is unsafe). # - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:165 def compactible_namespace?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:286 def const_namespace?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:174 def definition_elsewhere?(definition, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:125 def heuristic_namespace_keyword(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:114 def indexed_namespace_keyword(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:262 def leading_spaces(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:224 + def multiline_end_range(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:110 def namespace_keyword(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:281 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:319 def needs_compacting?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:96 def nest_definition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:86 def nest_or_compact(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:206 def remove_end(corrector, body); end + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:216 + def single_line_end_range(body); end + # A tab counts as `configured_indentation_width` columns, matching the # width `AlignmentCorrector` uses to convert `column_delta` back into # tabs. Using `Layout/IndentationStyle`'s own `IndentationWidth` here # would make the delta and the correction disagree. # - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:270 def spaces_size(spaces_string); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:136 def split_on_double_colon(corrector, node, padding); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:293 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:331 def style_for_classes; end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:289 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:327 def style_for_kind(kind); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:297 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:335 def style_for_modules; end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:230 def unindent(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:242 + def unindent_column_delta(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:252 + def unindentable_range(body); end + + class << self + # `Style/StructInheritance` turns a class definition into a constant assignment in + # the same pass, which the compacted `class` keyword would then precede. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:70 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:66 @@ -37904,7 +38785,7 @@ class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:82 def on_defs(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:71 @@ -37912,31 +38793,34 @@ class RuboCop::Cop::Style::ClassMethodsDefinitions < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:96 def all_methods_public?(sclass_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:123 def autocorrect_sclass(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:103 def def_nodes(sclass_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:92 def def_self_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:149 def extract_def_from_sclass(def_node, sclass_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:166 def indentation_diff(node1, node2); end + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:116 + def no_code_after?(range); end + # Splice in `self.` at the actual `def` keyword rather than substituting the # first textual `def `, which may appear inside a preceding comment. # - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:158 def prefix_def_with_self(range, def_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_methods_definitions.rb:145 def sclass_only_has_methods?(node); end end @@ -38487,39 +39371,81 @@ RuboCop::Cop::Style::CombinableDefined::OPERATORS = T.let(T.unsafe(nil), Array) # # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:62 class RuboCop::Cop::Style::CombinableLoops < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:68 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:83 def on_for(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:81 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:80 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:100 + # Comments and heredoc bodies before the closing delimiter are kept. When + # the next loop starts on the delimiter's line, the line break before the + # delimiter is kept too, so that a comment doesn't swallow the next loop. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:162 + def closing_with_preceding_space(loop, next_loop); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:97 def collection_looping_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:118 + def combinable_blocks?(node, sibling); end + + # Combining loops with different iteration variables would leave the second + # body referencing an undefined variable, so only autocorrect when they match. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:129 + def combinable_fors?(node, sibling); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:110 + def combinable_looping_blocks?(node, sibling); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:152 def combine_with_left_sibling(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:186 + def combined_with_right_sibling?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:177 def correct_end_of_block(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:105 + # The opening is removed, so a directive after it would end up on a line of + # its own, where it covers the rest of the file instead of a single line. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:135 + def directive_after_opening?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:196 + def first_combined_block(node); end + + # The block arguments or `{`/`do` of a block, or the `do` or collection of a `for` loop. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:144 + def loop_opening(node); end + + # Comments between the opening and the body are kept. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:171 + def opening_with_following_space(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:102 def same_collection_looping_block?(node, sibling); end - # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:114 def same_collection_looping_for?(node, sibling); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:65 +# pkg:gem/rubocop#lib/rubocop/cop/style/combinable_loops.rb:66 RuboCop::Cop::Style::CombinableLoops::MSG = T.let(T.unsafe(nil), String) # Enforces using `` or %x around command literals. @@ -38974,33 +39900,60 @@ RuboCop::Cop::Style::ComparableClamp::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Ar # # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:25 class RuboCop::Cop::Style::ConcatArrayLiterals < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:76 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:43 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:75 + # Whatever sits between the last element and the `]` of an array that isn't the + # last argument would end up before the following comma (a newline before it is a + # syntax error), so it's removed along with the `]`. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:131 + def closing_bracket_range(node, argument); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:110 + def comment_in?(range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:80 def offense_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:97 def percent_literals_includes_only_basic_literals?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:84 def preferred_method(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:103 + def rebuild_call(corrector, offense, replacement); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:116 + def remove_brackets(corrector, node); end + + class << self + # `Style/MethodCallWithArgsParentheses` removing the parentheses of the `push(...)` + # this cop writes in the same pass drops the line continuation a multiline call needs. + # `Style/TrailingCommaInArguments` adds a comma after the array literal this cop + # replaces with its elements in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:38 + def autocorrect_incompatible_with; end + end end -# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:28 +# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:29 RuboCop::Cop::Style::ConcatArrayLiterals::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:29 +# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:30 RuboCop::Cop::Style::ConcatArrayLiterals::MSG_FOR_PERCENT_LITERALS = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:31 +# pkg:gem/rubocop#lib/rubocop/cop/style/concat_array_literals.rb:32 RuboCop::Cop::Style::ConcatArrayLiterals::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for `if` and `case` statements where each branch is used for @@ -39107,81 +40060,81 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:219 def assignment_type?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:304 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:308 def candidate_condition?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_and_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:259 def on_case(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:265 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:269 def on_case_match(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_cvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_gvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:245 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_ivasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_lvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_masgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_op_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:231 def on_or_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:239 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:310 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:314 def allowed_single_line?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:404 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:408 def allowed_statements?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:310 def allowed_ternary?(assignment); end # `ReparsedEquivalence#correction_parses?` contract: apply the exact # correction this cop would perform. # - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:400 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:404 def apply_reparse_correction(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:314 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:318 def assignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:361 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:365 def assignment_types_match?(*nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:377 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:381 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:303 def candidate_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:277 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:281 def check_assignment_to_condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:367 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:371 def check_node(node, branches); end # If `Layout/LineLength` is enabled, we do not want to introduce an @@ -39192,25 +40145,25 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base # of the longest line + the length of the corrected assignment is # greater than the max configured line length # - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:420 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:424 def correction_exceeds_line_limit?(node, branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:443 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:447 def include_ternary?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:354 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:358 def lhs_all_match?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:432 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:436 def longest_line(node, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:428 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:432 def longest_line_exceeds_line_limit?(node, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:338 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:342 def move_assignment_inside_condition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:332 def move_assignment_outside_condition(corrector, node); end # The correction rewrites the conditional structurally, so full AST @@ -39221,14 +40174,19 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base # left alone instead of crashing or emitting invalid code - the bug # class behind most of this cop's history. # - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:392 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:396 def safe_to_correct?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:439 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:443 def single_line_conditions_only?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:350 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:354 def ternary_condition?(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:212 @@ -39312,27 +40270,27 @@ RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), # Helper module to provide common methods to ConditionalAssignment # correctors # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:450 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:454 module RuboCop::Cop::Style::ConditionalCorrectorHelper - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:487 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:491 def assignment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:516 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:520 def correct_branches(corrector, branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:493 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:497 def correct_if_branches(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:452 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:456 def remove_whitespace_in_branches(corrector, branch, condition, column); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:503 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:507 def replace_branch_assignment(corrector, branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:472 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:476 def same_line?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:476 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:480 def white_space_range(node, column); end end @@ -39972,7 +40930,8 @@ RuboCop::Cop::Style::DirectiveScope::MSG_PUSH_POP = T.let(T.unsafe(nil), String) # a `--` trailing justification comment is allowed, so a team can require # every disable to be documented instead of banning them outright. Enable # directives are not checked in this mode, since they end a suppression -# rather than start one. +# rather than start one. Offenses in this mode are not autocorrected, +# since only a human can supply the missing justification. # # This cop cannot be disabled via directive comments when it is explicitly # enabled with `Enabled: true`. This prevents users from bypassing the cop @@ -40013,62 +40972,82 @@ RuboCop::Cop::Style::DirectiveScope::MSG_PUSH_POP = T.let(T.unsafe(nil), String) # # # good # -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:92 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:93 class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:102 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:222 def allow_with_reason?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:231 def allowed_cops; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:218 def allowed_directives; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:241 def any_cops_allowed?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:120 def compute_disallowed_cops(directive_cops); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:197 def directive_cops(directive); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:245 def disallowed_cops_config; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:214 def exempt_mode?(directive); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:208 def ignored?(directive); end # A name matches either outright or through its department, so # `Metrics` covers `Metrics/AbcSize` but not the other way round. # - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:237 def listed?(names, cop); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:159 + def matching_pop(push_comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:187 def offense_message(disallowed_cops); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:129 - def register_offense(comment, directive_cops, disallowed_cops); end + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:164 + def pair_pushes_with_pops; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:132 + def register_offense(directive, directive_cops, disallowed_cops); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:182 + def remove_cops(corrector, comment, disallowed_cops); end + + # A `push` without its `pop` leaves an orphan `pop` behind, so the pair goes together. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:152 + def remove_directive(corrector, directive); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:176 + def remove_signed_args(corrector, directive, disallowed_cops); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:204 + def signed_args?(directive); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:96 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:97 RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:97 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:98 RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:98 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:99 RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_MISSING_REASON = T.let(T.unsafe(nil), String) # When using `class_eval` (or other `eval`) with string interpolation, @@ -40553,29 +41532,35 @@ class RuboCop::Cop::Style::DoubleNegation < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:91 def allowed_in_returns?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:122 def define_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:149 def double_negative_condition_return_value?(node, last_child, conditional_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:99 def end_of_method_definition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:131 def find_conditional_node_from_ascendant(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:114 def find_def_node_from_ascendant(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:138 def find_last_child(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:158 def find_parent_not_enumerable(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:95 + def negation?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:85 + def part_of_longer_negation?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/style/double_negation.rb:65 @@ -41292,10 +42277,13 @@ class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:105 + # A method with an argument spanning multiple lines (e.g. a hash default + # value) can't be put on a single line, so it's as compact as it gets. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:107 def compact?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:115 def compact_style?; end # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:77 @@ -41310,10 +42298,10 @@ class RuboCop::Cop::Style::EmptyMethod < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:95 def correction_exceeds_line_length?(correction); end - # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:111 def expanded?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:119 def expanded_style?; end # pkg:gem/rubocop#lib/rubocop/cop/style/empty_method.rb:99 @@ -41591,74 +42579,106 @@ RuboCop::Cop::Style::EndBlock::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:132 class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::LineLengthHelp include ::RuboCop::Cop::EndlessMethodRewriter + include ::RuboCop::Cop::EndlessMethodBodyHelp extend ::RuboCop::Cop::TargetRubyVersion extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:154 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:168 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:266 def arguments(node, missing = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:244 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:252 + def body_to_end_range(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:285 def can_be_made_endless?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:219 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:302 + def comment_in_discarded_range?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:227 def correct_to_endless(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:216 def endless_parent?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:256 def endless_replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:172 def handle_allow_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:206 def handle_disallow_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:197 def handle_require_always_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:183 def handle_require_single_line_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:310 + def line_when_made_endless(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:242 + def name_to_arguments_range(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:273 + def parenthesized_arguments(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:262 def receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:246 def signature_to_body_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:292 def single_line_when_made_endless?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:279 + def space_inside_parens?; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:296 def too_long_when_made_endless?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:238 + def unparenthesized_arguments?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:220 def use_heredoc?(node); end + + class << self + # `Style/MethodDefParentheses` adds the same parentheses a parameter list needs in + # an endless definition, so letting both correct in the same pass would double them. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:150 + def autocorrect_incompatible_with; end + end end -# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:140 +# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:142 RuboCop::Cop::Style::EndlessMethod::CORRECTION_STYLES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:141 +# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:143 RuboCop::Cop::Style::EndlessMethod::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:142 +# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:144 RuboCop::Cop::Style::EndlessMethod::MSG_MULTI_LINE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:144 +# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:146 RuboCop::Cop::Style::EndlessMethod::MSG_REQUIRE_ALWAYS = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:143 +# pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:145 RuboCop::Cop::Style::EndlessMethod::MSG_REQUIRE_SINGLE = T.let(T.unsafe(nil), String) # Checks for consistent usage of `ENV['HOME']`. If `nil` is used as @@ -41876,11 +42896,15 @@ RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for exact regexp match inside `Regexp` literals. # +# `=~` returns an index and `match` returns `MatchData`, so they are only +# autocorrected when their value is used as a condition. The same goes for +# safe navigation calls, which return `nil` for a `nil` receiver. +# # @example # # # bad # string =~ /\Astring\z/ -# string === /\Astring\z/ +# /\Astring\z/ === string # string.match(/\Astring\z/) # string.match?(/\Astring\z/) # @@ -41893,38 +42917,56 @@ RuboCop::Cop::Style::EvenOdd::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # good # string != 'string' # -# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:25 +# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:29 class RuboCop::Cop::Style::ExactRegexpMatch < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:38 def exact_regexp_match(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:59 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:40 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:45 def on_send(node); end private + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:63 + def autocorrect(corrector, node, prefer); end + + # `=~` returns an index, `match` returns `MatchData` and `&.` can return `nil`, + # so replacing them with `==` is only safe where the value is used as a condition. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:71 + def boolean_result?(node); end + # Escape characters that are special inside a single-quoted string so the # generated literal (e.g. for `/\Afoo'bar\z/`) stays valid Ruby. # - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:96 def escape_single_quotes(text); end - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:100 def exact_match_pattern?(parsed_regexp); end - # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:107 def new_method(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:88 + def parenthesize?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:75 + def truthiness_only?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:28 +# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:34 +RuboCop::Cop::Style::ExactRegexpMatch::BOOLEAN_METHODS = T.let(T.unsafe(nil), Set) + +# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:32 RuboCop::Cop::Style::ExactRegexpMatch::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:29 +# pkg:gem/rubocop#lib/rubocop/cop/style/exact_regexp_match.rb:33 RuboCop::Cop::Style::ExactRegexpMatch::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for use of the `File.expand_path` arguments. @@ -42060,10 +43102,10 @@ class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:60 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:65 def on_yield(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:49 @@ -42071,35 +43113,59 @@ class RuboCop::Cop::Style::ExplicitBlockArgument < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:140 def add_block_argument(node, corrector, block_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:160 + # A block parameter can't be added next to `...`. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:94 + def argument_forwarding?(def_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:200 def block_body_range(block_node, send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:112 + def block_name_taken?(def_node, block_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:189 def build_new_arguments_for_zsuper(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:163 def call_like?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:106 + def can_add_block_argument?(def_node, send_node, block_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:175 def correct_call_node(node, corrector, block_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:154 def empty_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:98 def extract_block_name(def_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:159 + def index_call?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:167 def insert_argument(node, corrector, block_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:127 def yielding_arguments?(block_args, yield_args); end + # A destructuring argument can only be passed on as the original value, + # and anonymous arguments can only be forwarded since Ruby 3.2. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:120 + def zsuper_arguments_forwardable?(def_node); end + class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:53 + # `Style/LambdaCall` rewrites the `call` that the block argument is appended to, and + # `Style/TrailingCommaInArguments` changes the trailing comma where it is appended, + # in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/explicit_block_argument.rb:56 def autocorrect_incompatible_with; end end end @@ -42774,19 +43840,25 @@ class RuboCop::Cop::Style::FloatDivision < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:140 def add_to_f_method(corrector, node); end # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:148 + def comment_before_to_f?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:168 def correct_from_slash_to_fdiv(corrector, receiver, argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:136 def message(_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:118 def offense_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:157 + def operands_losing_to_f(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/float_division.rb:144 def remove_to_f_method(corrector, send_node); end end @@ -42843,30 +43915,60 @@ class RuboCop::Cop::Style::For < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:76 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:63 def on_for(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:93 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:92 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:92 + # The loop variable becomes a block parameter, which can only be a local + # variable, and the body can't refer to an implicit block parameter + # (`_1` or `it`) once the block has an explicit one. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:100 + def convertible_to_each?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:130 + def do_end_block_in_collection?(node); end + + # Inside a numbered or `it` block, `_1` and `it` are local variables + # rather than method calls. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:109 + def implicit_parameter?(ref, for_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:116 + def implicit_parameter_reference?(ref); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:126 def rescue_or_ensure_body?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:122 def suspect_enumerable?(node); end + + class << self + # `Style/RedundantBegin` removes the `begin` of a block body in the same pass, + # leaving a `rescue` or `ensure` clause directly in the `for` body. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:59 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:52 RuboCop::Cop::Style::For::EACH_LENGTH = T.let(T.unsafe(nil), Integer) +# pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:55 +RuboCop::Cop::Style::For::IMPLICIT_PARAMETERS = T.let(T.unsafe(nil), Set) + # pkg:gem/rubocop#lib/rubocop/cop/style/for.rb:53 RuboCop::Cop::Style::For::PREFER_EACH = T.let(T.unsafe(nil), String) @@ -42927,6 +44029,9 @@ class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base def formatter(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:75 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:79 def on_send(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:71 @@ -42934,32 +44039,44 @@ class RuboCop::Cop::Style::FormatString < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:109 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:135 def autocorrect_from_percent(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:149 def autocorrect_to_percent(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:89 + # Only an argument that is provably not an array can be corrected, + # because `String#%` spreads an array argument and `format` does not. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:95 def autocorrectable?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:131 + def corrected_ranges; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:162 def format_single_parameter(arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:173 + def format_splatted_parameter(arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:101 def message(detected_style); end - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:105 def method_name(style_name); end # An argument that binds looser than `%` (a ternary, range, assignment, or # operator call) must be parenthesized to keep its meaning. # - # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:181 def requires_parentheses?(arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/format_string.rb:127 + def within_corrected_range?(node); end end # Known conversion methods whose return value is not an array. @@ -43254,10 +44371,10 @@ class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:179 def disabled_offense(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:191 def enable_comment(corrector); end # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:120 @@ -43269,34 +44386,34 @@ class RuboCop::Cop::Style::FrozenStringLiteralComment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:114 def ensure_no_comment(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:215 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:216 def following_comment; end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:153 def frozen_string_literal_comment(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:198 def insert_comment(corrector); end # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:137 def last_special_comment(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:208 def line_range(line); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:159 def missing_offense(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:165 def missing_true_offense(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:212 def preceding_comment; end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:187 def remove_comment(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/style/frozen_string_literal_comment.rb:171 def unnecessary_comment_offense(processed_source); end end @@ -43551,16 +44668,16 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:284 def accepted_form?(node, ending: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:294 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:302 def accepted_if?(node, ending); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:321 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:329 def allowed_consecutive_conditionals?; end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:274 def and_or_guard_clause?(guard_clause); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:305 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:313 def assigned_lvar_used_in_if_branch?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:204 @@ -43578,6 +44695,12 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:174 def consecutive_conditionals?(parent, node); end + # The body of an endless method is a single expression, so there is no + # room for a guard clause followed by the rest of the code. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:291 + def endless_method_body?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:229 def find_heredoc_argument(node); end @@ -43593,13 +44716,13 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:182 def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:325 def remove_whole_lines(corrector, range); end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:279 def too_long_for_single_line?(node, example); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:288 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:296 def trivial?(node); end class << self @@ -43726,37 +44849,59 @@ class RuboCop::Cop::Style::HashConversion < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:54 def hash_from_array?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:62 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:153 + # Without parentheses, a hash literal at the start of the first argument would be + # parsed as a block. That includes an argument like `Hash[a, b].merge(c)`. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:110 + def add_parentheses_to_parent_call(node, corrector); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:173 def allowed_splat_argument?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:166 def args_to_hash(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:159 def correct_multi_argument(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:147 def multi_argument(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:95 + # `foo[x]`, `foo.bar = x` and `foo == x` take a hash literal as it is. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:124 + def operator_syntax?(call); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:101 def register_offense_for_hash(node, hash_argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:128 def register_offense_for_zip_method(node, zip_method); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:138 def requires_parens?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:78 def single_argument(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:119 + def starts_parent?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:95 def use_zip_method_without_argument?(first_argument); end + + class << self + # A hash literal as the first argument needs the parentheses of the call, + # which `Style/MethodCallWithArgsParentheses` removes in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:58 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/hash_conversion.rb:49 @@ -44115,6 +45260,9 @@ RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) # # good - fetch with block is allowed # hash.fetch(key) { default } # +# # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled +# ENV.fetch(key) +# # @example EnforcedStyle: fetch # # bad # hash[key] @@ -44126,40 +45274,55 @@ RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) # # good # Rails.cache.fetch(name, options) { block } # -# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:48 +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:51 class RuboCop::Cop::Style::HashLookupMethod < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::AllowedReceivers extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:62 + def env_const?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:80 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:64 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:96 + def comment_before_dot?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:109 + def compound_assignment_target?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:119 def correct_brackets_to_fetch(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:113 def correct_fetch_to_brackets(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:100 + def env_fetch_preferred?(receiver); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:92 + def exempt_from_brackets?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:84 def offense_for_brackets?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:104 def offense_for_fetch?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:53 +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:56 RuboCop::Cop::Style::HashLookupMethod::BRACKET_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:54 +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:57 RuboCop::Cop::Style::HashLookupMethod::FETCH_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:56 +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:59 RuboCop::Cop::Style::HashLookupMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods @@ -44385,58 +45548,70 @@ class RuboCop::Cop::Style::HashSyntax < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:196 def alternative_style; end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:174 def hash_rockets_check(pairs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:188 def no_mixed_keys_check(pairs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:152 def on_hash(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:170 def ruby19_check(pairs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:178 def ruby19_no_mixed_keys_check(pairs); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:228 def acceptable_19_syntax_symbol?(sym_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:279 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:288 def argument_without_space?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:207 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:294 def autocorrect_hash_rockets(corrector, pair_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:294 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:307 def autocorrect_no_mixed_keys(corrector, pair_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:265 def autocorrect_ruby19(corrector, pair_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:248 def check(pairs, delim, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:315 def force_hash_rockets?(pairs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:301 + def operator_range(pair_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:280 def range_for_autocorrect_ruby19(pair_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:217 def sym_indices?(pairs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:221 def word_symbol_pair?(pair); end + + class << self + # Omitting the last hash value of a call without parentheses adds the parentheses, + # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses` + # would add again in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:148 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/hash_syntax.rb:140 @@ -44699,10 +45874,10 @@ class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:192 def check_expressions(node, expressions, insert_position); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:235 def correct_assignment(corrector, node, expression, insert_position); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:228 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:247 def correct_no_assignment(corrector, node, expression, insert_position); end # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:172 @@ -44711,29 +45886,35 @@ class RuboCop::Cop::Style::IdenticalConditionalBranches < ::RuboCop::Cop::Base # `elsif` branches show up in the if node as nested `else` branches. We # need to recursively iterate over all `else` branches. # - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:280 def expand_elses(branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:295 def head(node); end # The leading indentation of the line the conditional starts on, so a # hoisted expression keeps the surrounding nesting instead of landing # at column zero. # - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:260 def indentation_of(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:264 def last_child_of_parent?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:274 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:251 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:223 + def range_with_separator(range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:215 + def removal_range(expression); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:270 def single_child_branch?(branch_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/style/identical_conditional_branches.rb:291 def tail(node); end end @@ -44742,24 +45923,24 @@ RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), St # Corrector to correct conditional assignment in `if` statements. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:585 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:589 class RuboCop::Cop::Style::IfCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:590 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:594 def correct(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:594 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:598 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:608 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:612 def extract_tail_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:615 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:619 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -44829,29 +46010,42 @@ class RuboCop::Cop::Style::IfInsideElse < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:174 def allow_if_modifier?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:170 def allow_if_modifier_in_else_branch?(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:107 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:158 def comments_between_else_and_if?(node, else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:131 def correct_to_elsif_from_if_inside_else_form(corrector, node, condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:122 def correct_to_elsif_from_modifier_form(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:103 + def ends_its_line?(range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:147 def find_end_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:154 def if_condition_range(node, condition); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:97 + def moved_ranges(node); end + + # The `elsif` correction moves and removes whole lines, so it can't be applied when + # the nested `if` condition, its `if` branch or its `end` shares a line with other code. + # A modifier `if` on the `else` line would leave its body on the `elsif` line. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:90 + def shares_lines_with_other_code?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/style/if_inside_else.rb:65 @@ -44941,19 +46135,19 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:241 def another_modifier_if_on_same_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:255 def another_statement_on_same_line?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:153 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:235 def collection_from_ancestor(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:310 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:309 def comment_on_node_line(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:127 @@ -44965,64 +46159,64 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:115 def endless_method?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:297 - def extract_heredoc_from(last_argument); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:228 def find_containing_collection(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:301 + def heredoc_ranges_in(body); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:145 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:205 def multiline_inside_collection?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:196 def named_capture_in_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:200 def non_eligible_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:251 def non_simple_if_unless?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:137 def pattern_matching_nodes(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:314 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:313 def remove_comment(corrector, _node, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:304 - def remove_heredoc(corrector, heredoc); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:277 + def remove_heredoc(corrector, heredoc_ranges); end # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:162 def replacement_for_modifier_form(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:224 def shares_line_with?(inner, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:213 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:212 def sibling_if_shares_line?(child, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:290 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:294 def to_modifier_form_with_move_comment(node, indentation, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:269 def to_normal_form(node, indentation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:278 - def to_normal_form_with_heredoc(node, indentation, heredoc); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:283 + def to_normal_form_with_heredoc(node, indentation, heredoc_ranges); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:185 def too_long_due_to_comment_after_modifier?(node, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:180 def too_long_due_to_modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:191 def too_long_single_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:217 def unwrap_begin(node); end class << self @@ -45068,8 +46262,13 @@ class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base include ::RuboCop::Cop::StatementModifier extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:36 def on_if(node); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:31 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier_of_if_unless.rb:29 @@ -45195,49 +46394,73 @@ class RuboCop::Cop::Style::IfWithSemicolon < ::RuboCop::Cop::Base include ::RuboCop::Cop::OnNormalIfUnless extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:24 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:28 def on_normal_if_unless(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:55 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:59 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:147 def build_else_branch(second_condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:103 def build_expression(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:140 + def call_operand?(call, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:94 def correct_elsif(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:42 + # Expressions that bind looser than `?:` (or cannot appear unparenthesized + # inside it) would otherwise absorb or break the ternary. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:126 + def lower_precedence_than_ternary?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:46 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:133 + def operand_of_parent?(node); end + + # `!foo a` leaves the arguments of `foo` unparenthesized at the end of the operand, + # where they would absorb the rest of the ternary. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:169 + def prefix_bang_on_command?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:81 def replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:177 def require_argument_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:67 def require_newline?(node); end # An assignment used as the condition must be parenthesized, otherwise the # assignment would capture the whole ternary (`a = b ? c : d` instead of # `(a = b) ? c : d`), changing what gets assigned. # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:115 def ternary_condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:120 + def ternary_operand(expr); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:71 def use_masgn_or_block_in_branches?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:77 def use_return_with_argument?(node); end end +# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:24 +RuboCop::Cop::Style::IfWithSemicolon::LOWER_PRECEDENCE_THAN_TERNARY_TYPES = T.let(T.unsafe(nil), Array) + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_semicolon.rb:20 RuboCop::Cop::Style::IfWithSemicolon::MSG_IF_ELSE = T.let(T.unsafe(nil), String) @@ -45481,49 +46704,58 @@ class RuboCop::Cop::Style::InverseMethods < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:140 + def binary_operator?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:202 def camel_case_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:144 def correct_inverse_block(corrector, node); end # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:113 def correct_inverse_method(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:151 def correct_inverse_selector(block, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:206 def dot_range(loc); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:185 def end_parentheses(node, method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:173 def inverse_blocks; end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:168 def inverse_methods; end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:132 + def keep_parentheses?(node, method_call); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:216 def message(method, inverse); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:177 def negated?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:181 def not_to_receiver(node, method_call); end # When comparing classes, `!(Integer < Numeric)` is not the same as # `Integer > Numeric`. # - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:197 def possible_class_hierarchy_check?(lhs, rhs, method); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:210 def remove_end_parenthesis(corrector, node, method, method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:121 + def remove_negation(corrector, node, method, method_call); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/inverse_methods.rb:189 def safe_navigation_incompatible?(node); end class << self @@ -45860,19 +47092,36 @@ class RuboCop::Cop::Style::ItBlockParameter < ::RuboCop::Cop::Base extend ::RuboCop::Cop::TargetRubyVersion extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:70 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:101 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:88 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:142 + def block_variables(body, block_argument_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:118 def find_block_variables(node, block_argument_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:128 + def inner_block_ranges(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:132 + def used_within_inner_block?(body, block_argument_name); end + + class << self + # `Style/StabbyLambdaParentheses` wraps the parameter this cop removes in the same pass, + # which would leave an empty parameter list that forbids `it`. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:66 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/it_block_parameter.rb:59 @@ -46016,50 +47265,58 @@ RuboCop::Cop::Style::KeywordParametersOrder::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:49 class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PatternMatchingHelp + include ::RuboCop::Cop::RescueNode extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:70 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:87 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:86 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:138 def arguments_with_whitespace(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:127 def autocorrect_method_to_literal(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:142 def lambda_arg_string(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:112 def message(node, selector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:118 def message_line_modifier(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:91 def offending_selector?(node, selector); end + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:105 + def rescue_or_ensure_clause?(body); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:97 + def uncorrectable_lambda_literal?(node); end + class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:66 def autocorrect_incompatible_with; end end end -# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:53 +# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:55 RuboCop::Cop::Style::Lambda::LITERAL_MESSAGE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:54 +# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:56 RuboCop::Cop::Style::Lambda::METHOD_MESSAGE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:56 +# pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:58 RuboCop::Cop::Style::Lambda::OFFENDING_SELECTORS = T.let(T.unsafe(nil), Hash) # Checks for use of the lambda.(args) syntax. @@ -46083,7 +47340,7 @@ class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:51 def on_csend(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:28 @@ -46091,19 +47348,22 @@ class RuboCop::Cop::Style::LambdaCall < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:55 def comments_in_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:89 def explicit_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:63 + def heredoc_argument?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:85 def implicit_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:67 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda_call.rb:71 def prefer(node); end end @@ -46587,10 +47847,10 @@ class RuboCop::Cop::Style::MapIntoArray < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:113 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:129 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:128 def on_numblock(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:67 @@ -46598,37 +47858,37 @@ class RuboCop::Cop::Style::MapIntoArray < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:213 def correct_push_node(corrector, push_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:223 def correct_return_value_handling(corrector, block, dest_var); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:156 def dest_used_only_for_mapping?(block, dest_var, asgn); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:150 def find_closest_assignment(block, dest_var); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:133 def find_dest_var(block); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:181 def new_method_name; end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:141 def offending_empty_array_tap?(node, dest_var); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:164 def register_offense(block, dest_var, asgn); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:200 def remove_assignment(corrector, asgn); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:207 def remove_tap(corrector, node, block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/style/map_into_array.rb:187 def return_value_used?(node); end class << self @@ -47054,26 +48314,29 @@ class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:251 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:257 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:254 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:258 def on_yield(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:262 def args_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:270 def args_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:268 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:274 def args_parenthesized?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:283 + def mergeable_parentheses?(node); end + class << self # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses.rb:244 def autocorrect_incompatible_with; end @@ -47092,121 +48355,133 @@ module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses private - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:99 def allowed_camel_case_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:232 def allowed_chained_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:203 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:228 def allowed_multiline_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:104 def allowed_string_interpolation_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:241 def ambiguous_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:221 def ambiguous_range_argument?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:47 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:49 def apply_reparse_correction(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:246 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:280 def assigned_before?(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:288 def assignment_in_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:53 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:203 def call_as_argument_or_chain?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:196 def call_in_argument_with_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:148 def call_in_literals?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:157 def call_in_logical_operators?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:183 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:208 def call_in_match_pattern?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:170 def call_in_optional_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:174 def call_in_single_line_inheritance?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:179 def call_with_ambiguous_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:192 def call_with_braced_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:109 + def code_after_closing_parenthesis_on_its_own_line?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:257 + def command_assignment_before_keyword_operator?(node); end + + # Without the parentheses, a comment before the first argument would end the call there, + # and a line continuation can't carry the call past a comment. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:120 + def comment_before_first_argument?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:298 def forwards_anonymous_rest_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:266 def hash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:214 def hash_literal_in_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:69 def inside_endless_method_def?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:284 def inside_string_interpolation?(node); end # Require hash value omission be enclosed in parentheses to prevent the following issue: # https://bugs.ruby-lang.org/issues/18396. # - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:83 def last_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:135 def legitimate_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:228 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:253 def logical_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:91 def method_call_before_constant_resolution?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:65 def offense_range(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:33 def omit_parentheses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:127 def parentheses_at_the_end_of_multiline_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:270 def regexp_slash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:74 def require_parentheses_for_hash_value_omission?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:245 def splat?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:95 def super_call_without_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:87 def syntax_like_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:249 def ternary_if?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:274 def unary_literal?(node); end end @@ -47274,29 +48549,45 @@ RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses::REQUIRE_ class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:47 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:53 def on_csend(node); end + # The parentheses are significant when removing them changes how the + # code parses, e.g. when a local variable with the same name is in + # scope (`foo = 1; foo()`) or an operator follows (`foo() -1`). The + # candidates are verified together, since outside a method definition + # each one would otherwise reparse the whole file. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:60 + def on_investigation_end; end + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:37 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:43 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:91 def allowed_method_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:125 def any_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:79 + def apply_reparse_correction(corrector, range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:87 def default_argument?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:83 def ineligible_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:142 def offense_range(node); end # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning: @@ -47305,20 +48596,20 @@ class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < ::RuboCop::Cop::Ba # -e:1: warning: `it` calls without arguments will refer to the first block param in # Ruby 3.4; use it() or self.it # - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:113 def parenthesized_it_method_in_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:72 def register_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:95 def same_name_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:138 def variable_in_mass_assignment?(variable_name, node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_without_args_parentheses.rb:35 RuboCop::Cop::Style::MethodCallWithoutArgsParentheses::MSG = T.let(T.unsafe(nil), String) # Checks for methods called on a do...end block. The point of @@ -47469,25 +48760,34 @@ class RuboCop::Cop::Style::MethodDefParentheses < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:186 def anonymous_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:195 + def arguments_on_own_line?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:164 def arguments_without_parentheses?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:138 + def code_after_arguments?(arg_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:128 def correct_arguments(arg_node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:202 + def destructuring_first_argument?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:145 def forced_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:168 def missing_parentheses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:159 def require_parentheses?(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_def_parentheses.rb:178 def unwanted_parentheses(args); end class << self @@ -47716,31 +49016,34 @@ class RuboCop::Cop::Style::MissingElse < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:152 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:167 def case_style?; end # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:127 def check(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:185 def empty_else_config; end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:179 def empty_else_style; end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:135 + def guard_clause_cop_conflict?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:163 def if_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:141 def message_template; end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:175 def unless_else_config; end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_else.rb:171 def unless_else_cop_enabled?; end end @@ -48241,21 +49544,41 @@ class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::LineLengthHelp include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:25 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:26 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:38 + def autocorrect(corrector, node); end + + # Heredocs opened on the modifier line have their bodies after it, so + # they are moved along with the part of the `if` they belong to. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:50 + def heredoc_after(part, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:69 def indented_body(body, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:37 - def to_normal_if(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:60 + def to_normal_if(node, condition_heredoc, body_heredoc); end + + # The indentation of a line that starts inside a string is part of the + # string. Only squiggly heredocs strip it from their bodies, and a `<<` + # terminator has to stay at the start of its line. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:88 + def verbatim_line_range(str); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:81 + def verbatim_lines_in(body); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:22 +# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_modifier.rb:23 RuboCop::Cop::Style::MultilineIfModifier::MSG = T.let(T.unsafe(nil), String) # Checks for uses of the `then` keyword in multi-line `if` statements. @@ -48333,6 +49656,9 @@ class RuboCop::Cop::Style::MultilineInPatternThen < ::RuboCop::Cop::Base private + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_in_pattern_then.rb:59 + def ends_with_endless_range?(node); end + # Requires `then` for write `in` and its body on the same line. # # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_in_pattern_then.rb:51 @@ -48429,30 +49755,27 @@ class RuboCop::Cop::Style::MultilineMethodSignature < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:27 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:37 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:38 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:43 def autocorrect(corrector, node, begin_of_arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:75 def closing_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:79 def correction_exceeds_max_line_length?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:85 def definition_width(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:84 - def indentation_width(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:67 def last_line_source_of_arguments(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_method_signature.rb:71 def opening_line(node); end end @@ -48463,7 +49786,8 @@ RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String # # NOTE: `return if ... else ... end` is syntax error. If `return` is used before # multiline ternary operator expression, it will be autocorrected to single-line -# ternary operator. The same is true for `break`, `next`, and method call. +# ternary operator. The same is true for `break`, `next`, `yield`, `super`, +# `defined?` without parentheses, and method call. # # @example # # bad @@ -48489,42 +49813,42 @@ RuboCop::Cop::Style::MultilineMethodSignature::MSG = T.let(T.unsafe(nil), String # # return cond ? b : c # -# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:36 +# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:37 class RuboCop::Cop::Style::MultilineTernaryOperator < ::RuboCop::Cop::Base include ::RuboCop::Cop::CommentsHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:44 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:45 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:65 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:87 def comments_in_condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:93 def enforce_single_line_ternary_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:61 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:73 def replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:100 def use_assignment_method?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:41 RuboCop::Cop::Style::MultilineTernaryOperator::MSG_IF = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:41 +# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:42 RuboCop::Cop::Style::MultilineTernaryOperator::MSG_SINGLE_LINE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:42 +# pkg:gem/rubocop#lib/rubocop/cop/style/multiline_ternary_operator.rb:43 RuboCop::Cop::Style::MultilineTernaryOperator::SINGLE_LINE_TYPES = T.let(T.unsafe(nil), Array) # Checks uses of the `then` keyword @@ -48562,6 +49886,9 @@ class RuboCop::Cop::Style::MultilineWhenThen < ::RuboCop::Cop::Base private + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_when_then.rb:59 + def ends_with_endless_range?(node); end + # Requires `then` for write `when` and its body on the same line. # # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_when_then.rb:49 @@ -48779,49 +50106,46 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:162 - def on_assignment(value); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:156 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:347 def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:339 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:366 def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:313 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:340 def splat_value(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:221 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:304 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:331 def correct_splat_expansion(corrector, expr, splat_value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:279 def explicitly_frozen_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:246 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:255 def freezable_nested_literal?(node); end # Recursively freezes every nested mutable literal inside an array or # hash literal. Already-frozen subtrees are not re-frozen, but their # children are still inspected for unfrozen literals deeper down. # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:245 def freeze_nested_literals(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:296 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:313 def frozen_regexp_or_range_literals?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:295 def immutable_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:208 def literal_check(value); end # Returns the child literals of an array or hash node that may @@ -48829,29 +50153,47 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because # `.freeze` cannot be appended to their contents. # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:257 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:266 def literal_children(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:289 def mutable_literal?(value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:176 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:183 def mutable_nodes(value, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:216 def mutable_or_unfrozen_range?(value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:169 + def on_assignment(value); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:305 + def parenthesized_immutable_value?(value); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:285 def recursive?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:300 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:317 def requires_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:290 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:299 def shareable_constant_value?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:197 def strict_check(value); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:325 + def unparenthesized_method_call?(node); end + + class << self + # With `Recursive: true`, `.freeze` is appended to a nested literal. When the literal + # is the last element and spans multiple lines, the trailing comma lands between the literal + # and the `.freeze` appended in the same pass. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:152 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:147 @@ -49025,7 +50367,7 @@ class RuboCop::Cop::Style::NegatedIfElseCondition < ::RuboCop::Cop::Base # Collect the entire else branch, including whitespace and comments # - # pkg:gem/rubocop#lib/rubocop/cop/style/negated_if_else_condition.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/style/negated_if_else_condition.rb:127 def else_range(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/negated_if_else_condition.rb:70 @@ -49174,6 +50516,13 @@ end # and their combinations, allowing safe replacement when the receiver matches. # It works with variables, instance variables, class variables, and constants. # +# @safety +# This cop is unsafe because the receiver may not be an Array. For a Hash, +# `hash[hash.size - 1]` looks up the key `hash.size - 1`, which `hash[-1]` +# does not. Even for an Array, `arr[arr.length - n]` wraps around to an +# element from the end when `n` exceeds the length, while `arr[-n]` +# returns `nil`. +# # @example # # bad # arr[arr.count - 2] @@ -49189,84 +50538,84 @@ end # arr.sort[-2] # arr.sort.reverse[-2] # -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:29 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:36 class RuboCop::Cop::Style::NegativeArrayIndex < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:49 def length_subtraction?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:68 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:48 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:55 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:89 def add_offense_for_subtraction(node, index_arg, negative_index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:175 def build_current_source(receiver, range_without_parens, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:158 def build_message_for_range(receiver, start, range_op, index, current); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:134 def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:185 def build_range_without_parens(range_start, range_op, range_end, inner_end); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:165 def build_replacement_string(range_start, range_op, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:208 def extract_base_receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:85 def extract_inner_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:81 def extract_range_from_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:150 def format_range_message_parts(range_start, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:119 def handle_range_pattern(receiver, range_node, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:72 def handle_simple_index_pattern(node, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:217 def preserving_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:102 def range_with_length_subtraction?(range_node, array_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:191 def receivers_match?(length_receiver, array_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:195 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:203 def receivers_match_strict?(length_receiver, array_receiver); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:37 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:44 RuboCop::Cop::Style::NegativeArrayIndex::LENGTH_METHODS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:33 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:40 RuboCop::Cop::Style::NegativeArrayIndex::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:41 RuboCop::Cop::Style::NegativeArrayIndex::MSG_RANGE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:39 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:46 RuboCop::Cop::Style::NegativeArrayIndex::PRESERVING_METHODS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:35 +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:42 RuboCop::Cop::Style::NegativeArrayIndex::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for nested `File.dirname`. @@ -49323,42 +50672,48 @@ class RuboCop::Cop::Style::NestedModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:25 + def low_precedence?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:39 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:25 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:38 def on_until(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:22 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:35 def on_while(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:104 def add_parentheses_to_method_arguments(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:55 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:30 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:43 def check(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:78 def left_hand_operand(node, operator); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:38 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:51 def modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:64 def new_expression(inner_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:96 + def operand_source(condition); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:74 def replacement_operator(keyword); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:113 def requires_parens?(node, negated); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_modifier.rb:86 def right_hand_operand(node, left_hand_keyword); end end @@ -49438,13 +50793,22 @@ class RuboCop::Cop::Style::NestedTernaryOperator < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:39 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:43 def autocorrect(corrector, if_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:46 - def remove_parentheses(source); end + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:39 + def contains_heredoc?(node); end + + # An `if` right after `return`, as the operand of `not` or `defined?`, or as + # the first argument of a call without parentheses would be parsed as a modifier. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:64 + def modifier_position?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:55 + def remove_parentheses(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/nested_ternary_operator.rb:72 def replace_loc_and_whitespace(corrector, range, replacement); end end @@ -49559,7 +50923,7 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:249 def actual_indent(lines, buffer); end - # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:285 def allowed_consecutive_conditionals?; end # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:148 @@ -49577,7 +50941,7 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:206 def cond_range(node, cond); end - # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:281 def consecutive_conditionals?(if_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:225 @@ -49592,9 +50956,6 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:164 def exit_body_type?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:253 - def heredoc_lines(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:156 def if_else_children?(node); end @@ -49612,7 +50973,7 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:240 def reindent(lines, node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:274 def reindent_line(corrector, lineno, delta, buffer); end # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:229 @@ -49621,6 +50982,15 @@ class RuboCop::Cop::Style::Next < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:140 def simple_if_without_break?(node); end + # Lines that start inside a string literal or a heredoc body, whose + # leading whitespace is part of the string value. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:255 + def string_content_lines(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:266 + def string_content_range(node); end + class << self # pkg:gem/rubocop#lib/rubocop/cop/style/next.rb:90 def autocorrect_incompatible_with; end @@ -49673,25 +51043,31 @@ class RuboCop::Cop::Style::NilComparison < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:68 def autocorrect_to_comparison(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:77 def autocorrect_to_predicate(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:62 + def comment_before_dot?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:107 def message(_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:89 def operator_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:103 def operator_send?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:119 def prefer_comparison?; end # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:99 + def receiver_of_parent?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/nil_comparison.rb:111 def style_check?(node, &block); end end @@ -49891,15 +51267,18 @@ class RuboCop::Cop::Style::Not < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:63 def correct_opposite_method(corrector, range, child); end - # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:68 def correct_with_parens(corrector, range, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:73 def correct_without_parens(corrector, range); end + # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:77 + def operator_method_requiring_parens?(child); end + # pkg:gem/rubocop#lib/rubocop/cop/style/not.rb:52 def opposite_method?(child); end @@ -50267,42 +51646,48 @@ class RuboCop::Cop::Style::NumericPredicate < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedPattern extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:174 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:192 + def bitwise_predicate_candidate?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:182 def comparison(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:187 def inverted_comparison(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:90 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:177 def predicate(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:108 def allowed_method_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:118 def check(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:154 - def invert; end + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:169 + def comparison_requires_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:162 - def negated?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:112 + def handled_by_bitwise_predicate?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:161 + def invert; end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:141 def parenthesized_source(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:131 def replacement(node, numeric, operation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:153 def replacement_supported?(operator); end - # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/numeric_predicate.rb:149 def require_parentheses?(node); end end @@ -50525,37 +51910,40 @@ class RuboCop::Cop::Style::OneLineConditional < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:110 def always_multiline?; end # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:91 def autocorrect(corrector, node, multiline); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:114 def cannot_replace_to_ternary?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:136 def expr_replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:159 def keyword_with_changed_precedence?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:85 def message(node, multiline); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:152 def method_call_with_changed_precedence?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:81 def multiline?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:128 + def parent_binds_tighter_than_ternary?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:142 def requires_parentheses?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:99 def ternary_correction(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/one_line_conditional.rb:120 def ternary_replacement(node); end end @@ -51358,16 +52746,24 @@ class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:106 def contains_delimiter?(node, delimiters); end + # Without interpolation an escaped delimiter means something different + # once the delimiters change (`%q!it\!s!` is `"it!s"`, but `%q(it\!s)` + # is `"it\\!s"`). For a regexp the match stays the same, but its source + # changes. Interpolating literals read `\!` as `!` with any delimiter. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:100 + def contains_escaped_delimiter?(node, delimiters); end + # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:84 def contains_preferred_delimiter?(node, type); end # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:88 def include_same_character_as_used_for_delimiter?(node, type); end - # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:122 def matchpairs(begin_delimiter); end # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:69 @@ -51379,7 +52775,7 @@ class RuboCop::Cop::Style::PercentLiteralDelimiters < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:76 def preferred_delimiters_for(type); end - # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:112 def string_source(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/percent_literal_delimiters.rb:80 @@ -51963,12 +53359,18 @@ class RuboCop::Cop::Style::ReduceToHash < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:94 def check_offense(node, block_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:207 + def command_call?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:168 def do_end_replacement(block_node, body, arg = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:177 def element_arg_source(block_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:198 + def element_source(expr_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/reduce_to_hash.rb:194 def indent(node); end @@ -52353,28 +53755,31 @@ class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:131 def allowable_kwbegin?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:212 def begin_block_has_multiline_statements?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:204 def condition_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:218 def contain_rescue_or_ensure?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:197 def correct_modifier_form_after_multiline_begin_block(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:208 def empty_begin?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:228 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:245 def inspect_branches(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:167 + def low_precedence_statement?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:138 def register_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:174 def remove_begin(corrector, offense_range, node); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:155 @@ -52383,16 +53788,19 @@ class RuboCop::Cop::Style::RedundantBegin < ::RuboCop::Cop::Base # Restore comments that occur between "begin" and "first_child". # These comments will be moved to above the assignment line. # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:184 def restore_removed_comments(corrector, offense_range, node, first_child); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:235 + def too_long_when_joined?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:191 def use_modifier_form_after_multiline_begin_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:231 def valid_begin_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:217 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_begin.rb:224 def valid_context_using_only_begin?(node); end class << self @@ -52514,85 +53922,96 @@ class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base # If the argument is using an operator, it is an invalid syntax. # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`. # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:234 def argument_with_operator?(argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:211 def asgn_type?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:107 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:194 + # Any binary operator binds tighter than `||`, so the fallback must be + # parenthesized as its argument, e.g. `stack << (foo || :new)`. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:349 + def binary_operator?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:201 def branches_have_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:215 def branches_have_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:313 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:320 def correct_ternary(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:260 - def else_source(else_branch, arithmetic_operation); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:267 + def else_source(else_branch, binary_operator); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:293 def else_source_if_has_assignment(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:283 def else_source_if_has_method(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:191 def if_branch_is_true_type_and_else_is_not?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:243 - def if_source(if_branch, arithmetic_operation); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:250 + def if_source(if_branch, binary_operator); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:296 + # e.g. `not foo`, `return foo`, and `yield foo` + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:336 + def low_precedence_keyword?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:303 def make_ternary_form(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:99 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:128 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:121 def range_of_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:136 def redundant_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:95 + def redundant_condition_offense?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:343 def require_braces?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:321 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:328 def require_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:228 def same_method?(if_branch, else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:215 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:222 def single_argument_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:152 def synonymous_condition_and_branch?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:332 - def use_arithmetic_operation?(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:148 def use_hash_key_access?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:144 def use_hash_key_assignment?(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:140 def use_if_branch?(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:336 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:353 def without_argument_parentheses_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:242 def wrap_arguments_with_parens(condition); end end @@ -52812,47 +54231,55 @@ RuboCop::Cop::Style::RedundantCurrentDirectoryInPath::RESTRICT_ON_SEND = T.let(T class RuboCop::Cop::Style::RedundantDoubleSplatHashBraces < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:29 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:35 def on_hash(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:44 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:50 def allowed_double_splat_receiver?(kwsplat); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:60 def autocorrect(corrector, node, kwsplat); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:94 def autocorrect_merge_methods(corrector, merge_methods, kwsplat); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:90 def closing_brace(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:112 def convert_to_new_arguments(node); end # A braced hash literal passed to `merge` must have its braces stripped so # its pairs join the surrounding keyword arguments. Keeping the braces would # produce a positional hash after keyword arguments, which is invalid Ruby. # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:135 def hash_argument_source(hash); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:124 def mergeable?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:86 def opening_brace(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:105 def range_of_merge_methods(merge_methods); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:71 def root_receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:80 def select_merge_method_nodes(kwsplat); end + + class << self + # `Style/TrailingCommaInHashLiteral` adds a comma to the hash literal whose braces + # this cop removes in the same pass, which would leave a dangling comma. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:30 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_double_splat_hash_braces.rb:26 @@ -52947,10 +54374,10 @@ RuboCop::Cop::Style::RedundantEach::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arra class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:97 def compact?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:92 def exploded?(param0 = T.unsafe(nil)); end # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and @@ -52968,11 +54395,14 @@ class RuboCop::Cop::Style::RedundantException < ::RuboCop::Cop::Base def fix_exploded(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:71 - def replaced_compact(message); end + def message_source(message); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:51 def replaced_exploded(node, command, message); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:81 + def require_parentheses?(message); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_exception.rb:57 def string_message?(message); end end @@ -53028,7 +54458,7 @@ class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:55 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:82 def rails_cache?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:48 @@ -53036,23 +54466,26 @@ class RuboCop::Cop::Style::RedundantFetchBlock < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:97 def build_bad_method(send, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:90 def build_good_method(send, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:104 def check_for_constant?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:108 def check_for_string?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:86 def fetch_range(send, node); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:74 def should_not_check?(send, body); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:112 + def unappendable_argument?(send); end end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_fetch_block.rb:45 @@ -53371,6 +54804,9 @@ class RuboCop::Cop::Style::RedundantFreeze < ::RuboCop::Cop::Base include ::RuboCop::Cop::FrozenStringLiteral extend ::RuboCop::Cop::AutoCorrector + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_freeze.rb:68 + def numeric_operation?(param0 = T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_freeze.rb:26 def on_send(node); end @@ -53933,7 +55369,7 @@ class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:32 def allowed_pin_operator?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:198 def interpolation?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:39 @@ -53953,83 +55389,83 @@ class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:223 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:224 def allow_in_multiline_conditions?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:87 def allowed_ancestor?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:80 def allowed_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:92 def allowed_multiple_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:101 def allowed_ternary?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:265 def apply_reparse_correction(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:200 def argument_of_parenthesized_method_call?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:311 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:322 def body_range?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:228 def call_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:140 def check(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:232 def check_send(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:252 def check_unary(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:303 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:314 def disallowed_literal?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:339 def disallowed_one_line_pattern_matching?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:128 def empty_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:157 def find_offense_message(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:73 def ignore_syntax?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:133 def in_pattern_matching_in_method_argument?(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:310 def keyword_ancestor?(node); end # `and`/`or` keyword operators bind looser than the method-argument # boundary, so `foo((x and y))` cannot drop its parentheses without # becoming a syntax error (unlike `&&`/`||`). # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:335 def keyword_logical_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:337 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:348 def keyword_with_redundant_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:114 def like_method_argument_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:217 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:218 def method_call_parentheses_required?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:350 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:361 def method_call_with_redundant_parentheses?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:121 def multiline_control_flow_statements?(node); end # Grouping parentheses are transparent to the comparison: single-child @@ -54039,34 +55475,40 @@ class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base # z)` and `x && y && z` differ as trees but `&&` and `||` cannot be # redefined, so same-operator regrouping is semantically transparent). # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:275 def normalize_reparsed_ast(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:261 def offense(node, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:209 def oneline_rescue_parentheses_required?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:365 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:376 def only_begin_arg?(args); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:64 def parens_allowed?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:284 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:295 def rotate_same_operator(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:358 + # Like a variable assignment, `if (foo.bar = baz)` is a safe assignment + # that `Lint/AssignmentInCondition` asks for, not redundant parentheses. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:245 + def setter_in_condition?(begin_node, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:369 def singular_parenthesized_parent?(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:278 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:289 def splice_nested_sequences(children); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:295 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:306 def suspect_unary?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:107 def ternary_parentheses_required?; end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:60 @@ -54200,10 +55642,15 @@ class RuboCop::Cop::Style::RedundantRegexpArgument < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_argument.rb:65 def determinist_regexp?(regexp_node); end + # `#{`, `#$` and `#@` would start an interpolation in a double-quoted string. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_argument.rb:116 + def escape_interpolation_like_text(string); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_argument.rb:70 def preferred_argument(regexp_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_argument.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_argument.rb:98 def replacement(regexp_node); end end @@ -54310,6 +55757,17 @@ class RuboCop::Cop::Style::RedundantRegexpConstructor < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_constructor.rb:27 def redundant_regexp_constructor(param0 = T.unsafe(nil)); end + + private + + # `p / a/` and `p /=a/` parse as division, so a slash regexp starting + # with whitespace or `=` can't begin the first argument of a command. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_constructor.rb:50 + def ambiguous_slash_regexp?(node, regexp); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_constructor.rb:60 + def command?(call); end end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_constructor.rb:23 @@ -54353,28 +55811,33 @@ class RuboCop::Cop::Style::RedundantRegexpEscape < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:46 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:50 def on_regexp(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:65 def allowed_escape?(node, char, index, within_character_class); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:82 def char_class_begins_or_ends_with_escaped_hyphen?(node, index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:98 def delimiter?(node, char); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:114 def each_escape(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:126 def escape_range_at_index(node, index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:104 def requires_escape_to_avoid_interpolation?(node, index, escaped_char); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:46 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_regexp_escape.rb:41 @@ -55247,72 +56710,95 @@ class RuboCop::Cop::Style::RegexpLiteral < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:109 def on_regexp(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:175 def allow_inner_slashes?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:163 def allowed_mixed_percent_r?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:153 def allowed_mixed_slash?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:191 def allowed_omit_parentheses_with_percent_r_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:157 def allowed_percent_r_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:149 def allowed_slash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:136 def balanced_delimiters?(text, opening, closing, pattern); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:254 def calculate_replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:167 def contains_disallowed_slash?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:171 def contains_slash?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:208 def correct_delimiters(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:262 + def correct_escaped_delimiters(node, corrector); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:214 def correct_inner_slashes(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:277 + def delimiter_to_unescape(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:285 + def escaped_delimiter_indices(text, delimiter); end + + # A bare `#` before `{`, `@` or `$` would start an interpolation between slashes. + # `\#` still reads as a literal `#` there, except in extended mode, where `%r#a\#{b}#x` + # reads `#{b}` as a comment; `#\{` keeps both that comment and a `#` inside + # a character class. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:301 + def escaped_delimiter_replacement(node, delimiter, next_char); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:201 + def first_argument_of_command?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:231 def inner_slash_after_correction(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:227 def inner_slash_before_correction(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:246 def inner_slash_for(opening_delimiter); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:221 - def inner_slash_indices(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:235 + def inner_slash_indices(text, pattern); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:177 - def node_body(node, include_begin_nodes: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:179 + def node_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:129 def percent_r_delimiters_conflict?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:187 def preferred_delimiters; end - # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:183 def slash_literal?(node); end end +# pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:107 +RuboCop::Cop::Style::RegexpLiteral::DELIMITERS_KEEPING_ESCAPE = T.let(T.unsafe(nil), Array) + # pkg:gem/rubocop#lib/rubocop/cop/style/regexp_literal.rb:99 RuboCop::Cop::Style::RegexpLiteral::MSG_USE_PERCENT_R = T.let(T.unsafe(nil), String) @@ -55395,22 +56881,25 @@ class RuboCop::Cop::Style::RequireOrder < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:124 def autocorrect(corrector, node, previous_older_sibling); end - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:103 def find_previous_older_sibling(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:142 def in_same_section?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:99 def not_modifier_form?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:117 + def own_lines?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:132 def search_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/require_order.rb:136 def sibling_node(node); end end @@ -55467,16 +56956,16 @@ class RuboCop::Cop::Style::RescueModifier < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:74 def correct_rescue_block(corrector, node, parenthesized); end - # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:100 def heredoc_end(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:90 def indentation_and_offset(node, parenthesized); end - # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/rescue_modifier.rb:69 def parenthesized?(node); end class << self @@ -55622,10 +57111,10 @@ class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:105 def chained_send?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:108 def define_method?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:48 @@ -55645,8 +57134,14 @@ class RuboCop::Cop::Style::ReturnNil < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:76 def message(_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:93 + def return_nil(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:89 def scoped_node?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:85 + def top_level_return?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil.rb:39 @@ -55735,13 +57230,13 @@ class RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition < ::RuboCop::Cop private - # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:138 def handle_if(if_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:113 def handle_implicit_return_values(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:132 def handle_nil(nil_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:118 @@ -55755,6 +57250,9 @@ class RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition < ::RuboCop::Cop # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:107 def register_offense(offense_node, replacement); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:125 + def requires_parentheses?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:74 @@ -56101,22 +57599,22 @@ class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:128 def correction(shuffle_arg, method, method_args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:144 def extract_source(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:122 def message(shuffle_arg, method, method_args, range); end # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:65 def offensive?(method, method_args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:101 def range_size(range_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:135 def sample_arg(method, method_args); end # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:76 @@ -56128,8 +57626,11 @@ class RuboCop::Cop::Style::Sample < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:95 def sample_size_for_two_args(first, second); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:118 def source_range(shuffle_node, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:114 + def zero_or_beginless?(low); end end # pkg:gem/rubocop#lib/rubocop/cop/style/sample.rb:37 @@ -56466,27 +57967,24 @@ class RuboCop::Cop::Style::SelfAssignment < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:88 - def apply_autocorrect(corrector, node, rhs, operator, new_rhs); end + # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:85 + def apply_autocorrect(corrector, node, operator, new_rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:75 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:84 - def autocorrect_boolean_node(corrector, node, rhs); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:80 - def autocorrect_send_node(corrector, node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:39 def check(node, var_type); end - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:65 def check_boolean_node(node, rhs, var_name, var_type); end - # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:49 + # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:54 def check_send_node(node, rhs, var_name, var_type); end + # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:49 + def unparenthesized(node); end + class << self # pkg:gem/rubocop#lib/rubocop/cop/style/self_assignment.rb:21 def autocorrect_incompatible_with; end @@ -56559,25 +58057,28 @@ class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:116 def exist_semicolon_before_right_string_interpolation_brace?(tokens); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:175 def expressions_per_line(exprs); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:189 def find_node(nodes, token_before_semicolon); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:181 def find_semicolon_positions(line); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:154 def heredoc_opened_before_semicolon?(semicolon_range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:165 + def parenthesize_arguments(corrector, hash_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:195 def range_nodes; end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:124 def register_semicolon(line, column, after_expression, token_before_semicolon = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:146 def replace_semicolon_with_line_break(corrector, range); end # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:87 @@ -56586,7 +58087,10 @@ class RuboCop::Cop::Style::Semicolon < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:82 def tokens_for_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:161 + def value_omission_hash(token_before_semicolon); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/semicolon.rb:203 def value_omission_pair_nodes; end class << self @@ -57073,54 +58577,61 @@ RuboCop::Cop::Style::SingleLineDoEndBlock::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:36 class RuboCop::Cop::Style::SingleLineMethods < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::EndlessMethodBodyHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:44 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:51 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:63 def allow_empty?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:55 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:104 def break_line_before(corrector, node, range, indent_steps: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:95 def correct_to_endless(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:67 def correct_to_endless?(body_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:81 def correct_to_multiline(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:153 def disallow_endless_method_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:111 def each_part(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:146 + def endless_arguments(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:128 def method_body_source(method_body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:121 def move_comment(node, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:139 def require_parentheses?(method_body); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:76 + def unsupported_endless_method_body?(body_node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:41 RuboCop::Cop::Style::SingleLineMethods::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:41 +# pkg:gem/rubocop#lib/rubocop/cop/style/single_line_methods.rb:42 RuboCop::Cop::Style::SingleLineMethods::NOT_SUPPORTED_ENDLESS_METHOD_BODY_TYPES = T.let(T.unsafe(nil), Array) # Checks that arrays are not sliced with the redundant `ary[0..-1]`, replacing it with `ary`, @@ -57540,25 +59051,37 @@ class RuboCop::Cop::Style::StabbyLambdaParentheses < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:59 + def arguments_require_parentheses?(arguments); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:65 + def comment_inside_parentheses?(arguments); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:70 + def leading_padding(arguments); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:82 def message(_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:48 def missing_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:86 def missing_parentheses_corrector(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:99 def parentheses?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:52 def redundant_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:95 def stabby_lambda_with_args?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:76 + def trailing_padding(arguments); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/stabby_lambda_parentheses.rb:90 def unwanted_parentheses_corrector(corrector, node); end end @@ -57810,13 +59333,16 @@ class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:139 def corrected_ancestor?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:191 def double_quoted?(str_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:183 + def file_keyword?(str_node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:106 def find_topmost_plus_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:177 def handle_quotes(parts); end # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:133 @@ -57825,7 +59351,7 @@ class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:96 def line_end_concatenation?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:195 def mode; end # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:125 @@ -57837,7 +59363,7 @@ class RuboCop::Cop::Style::StringConcatenation < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:143 def replacement(parts); end - # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:187 def single_quoted?(str_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/string_concatenation.rb:129 @@ -58216,43 +59742,43 @@ class RuboCop::Cop::Style::SuperArguments < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:127 def argument_list_size_differs?(def_args, super_args, super_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:110 def arguments_identical?(def_node, super_node, def_args, super_args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:182 def block_arg_same?(def_node, super_node, def_arg, super_arg); end # Reassigning the block argument will still pass along the original block to super # https://bugs.ruby-lang.org/issues/20505 # - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:196 def block_reassigned?(def_node, block_arg_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:136 def block_sends_to_super?(super_node, parent_node = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:98 def find_def_node(super_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:207 def forward_arg_same?(def_arg, super_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:162 def keyword_arg_same?(def_arg, super_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:172 def keyword_rest_arg_same?(def_arg, super_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:145 def positional_arg_same?(def_arg, super_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:152 def positional_rest_arg_same?(def_arg, super_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/super_arguments.rb:211 def preprocess_super_args(super_args); end end @@ -58608,82 +60134,89 @@ class RuboCop::Cop::Style::SymbolProc < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::PatternMatchingHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:194 def destructuring_block_argument?(argument_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:171 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:173 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:192 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:187 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:191 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:154 def proc_node?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:160 def symbol_proc?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:157 def symbol_proc_receiver?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:275 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:293 def allow_comments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:289 def allow_if_method_has_argument?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:209 def allowed_method_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:236 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:266 def autocorrect_lambda_block(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:257 def autocorrect_with_args(corrector, node, args, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:244 def autocorrect_without_args(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:279 def begin_pos_for_replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:274 def block_range_with_space(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:226 + def message(node, method_name, block_method_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:213 def register_offense(node, method_name, block_method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:205 def unsafe_array_usage?(node); end # See: https://github.com/rubocop/rubocop/issues/10864 # - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:201 def unsafe_hash_usage?(node); end class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:168 def autocorrect_incompatible_with; end end end -# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:149 +# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:151 RuboCop::Cop::Style::SymbolProc::LAMBDA_OR_PROC = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:147 +# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:148 RuboCop::Cop::Style::SymbolProc::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:148 +# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:149 +RuboCop::Cop::Style::SymbolProc::MSG_LAMBDA_LITERAL = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/symbol_proc.rb:150 RuboCop::Cop::Style::SymbolProc::SUPER_TYPES = T.let(T.unsafe(nil), Array) # Checks for manual counting patterns that can be replaced by `Enumerable#tally`. @@ -58772,36 +60305,36 @@ RuboCop::Cop::Style::TallyMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Corrector to correct conditional assignment in ternary conditions. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:525 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:529 class RuboCop::Cop::Style::TernaryCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:530 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:534 def correct(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:534 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:538 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:548 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:552 def correction(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:561 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:565 def element_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:565 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:569 def extract_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:578 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:582 def move_branch_inside_condition(corrector, branch, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:573 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:577 def remove_parentheses(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:552 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:556 def ternary(node); end end end @@ -58863,96 +60396,110 @@ class RuboCop::Cop::Style::TernaryParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:204 def method_name(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:70 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:100 + # Whatever binds looser than the ternary operator (`n += 1`, `a rescue b`, + # a nested ternary, `yield a`, several statements, ...) changes + # meaning without the parentheses, so their removal is verified by + # reparsing. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:227 + def apply_reparse_correction(corrector, condition); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:101 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:194 def below_ternary_precedence?(child); end # If the condition is parenthesized we recurse and check for any # complex expressions within it. # - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:137 def complex_condition?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:90 def condition_as_parenthesized_one_line_pattern_matching?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:209 def correct_parenthesized(corrector, condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:243 def correct_unparenthesized(corrector, condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:157 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:260 def node_args_need_parens?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:267 def node_with_args?(node); end # Anything that is not a variable, constant, or method/.method call # will be counted as a complex expression. # - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:147 def non_complex_expression?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:151 def non_complex_send?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:113 + # The removed parentheses are the only expected difference. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:232 + def normalize_reparsed_ast(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:115 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:86 def only_closing_parenthesis_is_last_line?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:247 def parenthesize_condition_arguments(corrector, send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:175 def parenthesized?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:183 def parenthesized_modifier_condition?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:167 def require_parentheses?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:171 def require_parentheses_when_complex?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:190 def unparenthesized_method_call?(child); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:179 def unsafe_autocorrect?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:255 def whitespace_after?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:66 +# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:67 RuboCop::Cop::Style::TernaryParentheses::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:67 +# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:68 RuboCop::Cop::Style::TernaryParentheses::MSG_COMPLEX = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:64 +# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:65 RuboCop::Cop::Style::TernaryParentheses::NON_COMPLEX_TYPES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:63 +# pkg:gem/rubocop#lib/rubocop/cop/style/ternary_parentheses.rb:64 RuboCop::Cop::Style::TernaryParentheses::VARIABLE_TYPES = T.let(T.unsafe(nil), Set) # Checks for `Time.new` without arguments, which is an implicit way @@ -59748,46 +61295,49 @@ class RuboCop::Cop::Style::TrailingUnderscoreVariable < ::RuboCop::Cop::Base include ::RuboCop::Cop::SurroundingSpace extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:41 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:42 def on_masgn(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:93 def allow_named_underscore_variables; end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:127 def children_offenses(variables); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:58 def find_first_offense(variables); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:67 def find_first_possible_offense(variables); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:109 def main_node_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:149 def range_for_parentheses(offense, left); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:89 def reverse_index(collection, item); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:81 def splat_variable_before?(first_offense, variables); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:97 def unneeded_ranges(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:131 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:135 def unused_range(node, mlhs_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:131 def unused_variables_only?(offense, variables); end end # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:38 +RuboCop::Cop::Style::TrailingUnderscoreVariable::ARRAY_OPENING = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:39 RuboCop::Cop::Style::TrailingUnderscoreVariable::DISALLOW = T.let(T.unsafe(nil), Array) # pkg:gem/rubocop#lib/rubocop/cop/style/trailing_underscore_variable.rb:36 @@ -60532,40 +62082,43 @@ class RuboCop::Cop::Style::YodaCondition < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:152 - def actual_code_range(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:141 + def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:149 def constant_portion?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:141 - def corrected_code(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:113 def enforce_yoda?; end # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:117 def equality_only?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:176 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:191 def interpolation?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:137 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:153 + def move_argument_to_front(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:162 + def move_receiver_to_back(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:175 def non_equality_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:179 def noncommutative_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:187 def program_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:156 - def reverse_comparison(operator); end + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:169 + def reverse_comparison(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:183 def source_file_path_constant?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_condition.rb:126 @@ -60637,30 +62190,36 @@ RuboCop::Cop::Style::YodaCondition::REVERSE_COMPARISON = T.let(T.unsafe(nil), Ha class RuboCop::Cop::Style::YodaExpression < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:47 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:50 def on_new_investigation; end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:51 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:54 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:77 def constant_portion?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:91 def offended_ancestor?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:95 def offended_nodes; end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:81 + def operand?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:87 def supported_operators; end - # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:73 def yoda_expression_constant?(lhs, rhs); end end +# pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:46 +RuboCop::Cop::Style::YodaExpression::ARGUMENT_ONLY_TYPES = T.let(T.unsafe(nil), Array) + # pkg:gem/rubocop#lib/rubocop/cop/style/yoda_expression.rb:43 RuboCop::Cop::Style::YodaExpression::MSG = T.let(T.unsafe(nil), String) @@ -60937,6 +62496,9 @@ class RuboCop::Cop::Team # pkg:gem/rubocop#lib/rubocop/cop/team.rb:163 def autocorrect(processed_source, corrector); end + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:359 + def autocorrect_incompatible?(cop_class, other); end + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:185 def be_ready; end @@ -60949,10 +62511,10 @@ class RuboCop::Cop::Team # pkg:gem/rubocop#lib/rubocop/cop/team.rb:344 def each_corrector(report); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:396 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:401 def handle_error(error, location, cop); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:388 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:393 def handle_warning(error, location); end # pkg:gem/rubocop#lib/rubocop/cop/team.rb:235 @@ -60986,7 +62548,7 @@ class RuboCop::Cop::Team # pkg:gem/rubocop#lib/rubocop/cop/team.rb:257 def partition_by_correcting(cops); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:371 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:376 def process_errors(file, errors); end # pkg:gem/rubocop#lib/rubocop/cop/team.rb:194 @@ -61004,10 +62566,10 @@ class RuboCop::Cop::Team # pkg:gem/rubocop#lib/rubocop/cop/team.rb:300 def support_target_ruby_version?(cop); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:359 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:364 def suppress_clobbering; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:365 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:370 def validate_config; end class << self @@ -62399,7 +63961,7 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:15 def initialize(name, declaration_node, scope); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:129 def argument?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:31 @@ -62408,10 +63970,10 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def assignments; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:137 def block_argument?; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:109 def capture_with_block!; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 @@ -62420,28 +63982,35 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:13 def captured_by_block?; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:105 def covers?(container, node); end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def declaration_node; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:132 + # A branch nested in the main body of `begin` can be cut short by an exception + # too. An earlier assignment in it is visible to a reference in the `rescue` or + # `ensure` clause, or after a `rescue` that handles the exception. + # + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:90 + def exception_may_reach?(branch, reference_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:145 def explicit_block_local_variable?; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:77 def in_modifier_conditional?(assignment, reference_node); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:141 def keyword_argument?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:39 def mark_last_as_reassigned!(assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:133 def method_argument?; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:99 def modifier_conditional_of(node); end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 @@ -62459,7 +64028,7 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def scope; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:125 def should_be_unused?; end # This is a convenient way to check whether the variable is used @@ -62471,7 +64040,7 @@ class RuboCop::Cop::VariableForce::Variable # This means we cannot track the usage of the variable. # So we consider it's used to suppress false positive offenses. # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:121 def used?; end end @@ -63275,17 +64844,18 @@ end # * `#file_started` # * `#file_finished` # * `#file_started` +# * `#file_problems` (only when a cop crashed or warned on the file) # * `#file_finished` # * `#finished` # -# pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:41 +# pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:42 class RuboCop::Formatter::BaseFormatter # @api public # # @param output [IO] # `$stdout` or opened file # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:63 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:64 def initialize(output, options = T.unsafe(nil)); end # @api public @@ -63302,9 +64872,32 @@ class RuboCop::Formatter::BaseFormatter # # @see RuboCop::Cop::Offense # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:104 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:126 def file_finished(file, offenses); end + # @api public + # + # Invoked before `#file_finished` for a file that a cop crashed on or + # raised a warning for, or whose corrections went into an infinite loop. + # Optional: a formatter implementing the API by duck typing is skipped + # when it doesn't define it. + # + # @param file [String] + # the file path + # + # @param errors [Array(String)] + # the error messages as they're printed, without colors. A cop that + # crashes on every node of a kind has a message for each, naming the + # line and column. + # + # @param warnings [Array(String)] + # the warning messages, in the same form + # + # @return [void] + # + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:111 + def file_problems(file, errors, warnings); end + # @api public # # Invoked at the beginning of inspecting each files. @@ -63317,7 +64910,7 @@ class RuboCop::Formatter::BaseFormatter # # @return [void] # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:89 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:90 def file_started(file, options); end # @api public @@ -63331,7 +64924,7 @@ class RuboCop::Formatter::BaseFormatter # # @return [void] # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:116 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:138 def finished(inspected_files); end # @api public @@ -63340,7 +64933,7 @@ class RuboCop::Formatter::BaseFormatter # # @return [Hash] # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:57 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:58 def options; end # @api public @@ -63352,7 +64945,7 @@ class RuboCop::Formatter::BaseFormatter # # @see #initialize # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:50 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:51 def output; end # @api public @@ -63364,7 +64957,7 @@ class RuboCop::Formatter::BaseFormatter # # @return [void] # - # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:76 + # pkg:gem/rubocop#lib/rubocop/formatter/base_formatter.rb:77 def started(target_files); end end @@ -63605,15 +65198,18 @@ class RuboCop::Formatter::FormatterSet < ::Array # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:41 def initialize(options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:57 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:61 def add_formatter(formatter_type, output_path = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:69 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:73 def close_output_files; end - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:52 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:56 def file_finished(file, offenses); end + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:52 + def file_problems(file, errors, warnings); end + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:46 def file_started(file, options); end @@ -63625,13 +65221,13 @@ class RuboCop::Formatter::FormatterSet < ::Array private - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:88 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:92 def builtin_formatter_class(specified_key); end - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:106 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:110 def custom_formatter_class(specified_class_name); end - # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:77 + # pkg:gem/rubocop#lib/rubocop/formatter/formatter_set.rb:81 def formatter_class(formatter_type); end end @@ -63937,28 +65533,52 @@ class RuboCop::Formatter::JSONFormatter < ::RuboCop::Formatter::BaseFormatter # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:13 def initialize(output, options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:22 - def file_finished(file, offenses); end + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:110 + def correction_for(offense); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:114 + def edits_for(offense); end # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:27 + def file_finished(file, offenses); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:23 + def file_problems(file, errors, warnings); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:36 def finished(inspected_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:42 + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:130 + def hash_for_edit_range(range); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:52 def hash_for_file(file, offenses); end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:69 + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:139 def hash_for_location(offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:49 + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:85 def hash_for_offense(offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:32 + # A cop that crashes fails once per node it visits, so messages that + # differ only in their line and column are listed once, at the first place + # they happened. They name the file the way its entry does. The keys are + # absent when there's nothing to report, which keeps them additive for + # existing consumers. + # + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:64 + def hash_for_problems(file, errors, warnings); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:42 def metadata_hash; end # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:11 def output_hash; end - # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:18 + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:78 + def problem_counts(files); end + + # pkg:gem/rubocop#lib/rubocop/formatter/json_formatter.rb:19 def started(target_files); end end @@ -64102,28 +65722,30 @@ end # # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:16 class RuboCop::Formatter::OffenseCountFormatter < ::RuboCop::Formatter::BaseFormatter - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:80 + include ::RuboCop::Formatter::TextUtil + + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:82 def cop_information(cop_name); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:42 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:44 def file_finished(_file, offenses); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:51 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:53 def finished(_inspected_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:17 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:19 def offense_counts; end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:72 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:74 def ordered_offense_counts(offense_counts); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:56 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:58 def report_summary(offense_counts, offending_files_count); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:19 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:21 def started(target_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:76 + # pkg:gem/rubocop#lib/rubocop/formatter/offense_count_formatter.rb:78 def total_offense_count(offense_counts); end end @@ -64133,54 +65755,54 @@ end # This is inspired by the Pacman formatter for RSpec by Carlos Rojas. # https://github.com/go-labs/rspec_pacman_formatter # -# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:10 +# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:12 class RuboCop::Formatter::PacmanFormatter < ::RuboCop::Formatter::ClangStyleFormatter include ::RuboCop::Formatter::TextUtil - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:20 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:22 def initialize(output, options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:51 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:53 def cols; end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:38 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:40 def file_finished(file, offenses); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:34 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:36 def file_started(_file, _options); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:44 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:46 def next_step(offenses); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:65 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:67 def pacdots(number); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:13 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:15 def progress_line; end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:13 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:15 def progress_line=(_arg0); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:27 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:29 def started(target_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:69 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:71 def step(character); end - # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:58 + # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:60 def update_progress_line; end end -# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:15 +# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:17 RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer) -# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:16 +# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:18 RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:18 +# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:20 RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter) -# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:17 +# pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:19 RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter) # This formatter display dots for files with no offenses and @@ -64237,7 +65859,7 @@ class RuboCop::Formatter::SARIFFormatter < ::RuboCop::Formatter::BaseFormatter # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:36 def file_started(_file, options); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:46 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:47 def finished(_inspected_files); end private @@ -64245,28 +65867,31 @@ class RuboCop::Formatter::SARIFFormatter < ::RuboCop::Formatter::BaseFormatter # `file_started` is not called when a formatter is used directly through # the API, so there may be no config to consult. # - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:172 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:177 def config_for(file); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:166 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:171 def cop_config(file, offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:159 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:164 def default_level_for(file, offense, cop_class); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:155 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:160 def description_for(file, offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:60 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:61 def driver; end # GitHub uses these to match an alert across runs. Without them it falls # back to the file path, which makes alerts churn whenever a file moves. + # Repeats of the same hash within a file get a `:N` suffix, like GitHub's + # own fingerprints, so two offenses on one line don't merge into one alert. + # The first occurrence keeps the bare hash to match earlier reports. # - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:113 - def fingerprints_for(offense); end + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:117 + def fingerprints_for(offense, line_hash_counts); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:149 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:154 def help_for(description, help_uri); end # The URI is relative to the working directory, which is what consumers @@ -64274,28 +65899,28 @@ class RuboCop::Formatter::SARIFFormatter < ::RuboCop::Formatter::BaseFormatter # have to be declared under `originalUriBaseIds` to mean anything, and # every consumer that matters resolves relative paths without it. # - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:91 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:92 def location_for(file, offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:100 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:101 def region_for(offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:52 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:53 def report; end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:70 - def result_for(file, offense); end + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:71 + def result_for(file, offense, line_hash_counts); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:131 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:136 def rule_for(file, offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:124 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:129 def rule_index_for(file, offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:118 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:123 def suppression_for(offense); end - # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:176 + # pkg:gem/rubocop#lib/rubocop/formatter/sarif_formatter.rb:181 def uri_for(file); end end @@ -64443,25 +66068,27 @@ end # # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:16 class RuboCop::Formatter::WorstOffendersFormatter < ::RuboCop::Formatter::BaseFormatter - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:24 + include ::RuboCop::Formatter::TextUtil + + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:26 def file_finished(file, offenses); end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:31 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:33 def finished(_inspected_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:17 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:19 def offense_counts; end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:54 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:56 def ordered_offense_counts(offense_counts); end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:36 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:38 def report_summary(offense_counts); end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:19 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:21 def started(target_files); end - # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:58 + # pkg:gem/rubocop#lib/rubocop/formatter/worst_offenders_formatter.rb:60 def total_offense_count(offense_counts); end end @@ -64942,6 +66569,34 @@ end # pkg:gem/rubocop#lib/rubocop/ast_aliases.rb:5 RuboCop::NodePattern = RuboCop::AST::NodePattern +# Caps how many offenses each cop gets to report. +# +# Counted across a whole run rather than per file, since a cop that fires a +# handful of times in every file is exactly the one worth capping. Offenses +# have to be offered in a stable order (files in the order they are +# reported) for the same ones to survive every time. +# @api private +# +# pkg:gem/rubocop#lib/rubocop/offense_limit.rb:11 +class RuboCop::OffenseLimit + # pkg:gem/rubocop#lib/rubocop/offense_limit.rb:14 + def initialize(max); end + + # @return [Hash{String => Integer}] how many offenses each cop had left out, + # sorted by cop name + # + # pkg:gem/rubocop#lib/rubocop/offense_limit.rb:26 + def elided_per_cop; end + + # @return [Array] the offenses still within their cop's limit + # + # pkg:gem/rubocop#lib/rubocop/offense_limit.rb:20 + def filter(offenses); end + + # pkg:gem/rubocop#lib/rubocop/offense_limit.rb:12 + def max; end +end + # pkg:gem/rubocop#lib/rubocop/options.rb:10 class RuboCop::OptionArgumentError < ::StandardError; end @@ -64958,7 +66613,7 @@ class RuboCop::Options private - # pkg:gem/rubocop#lib/rubocop/options.rb:260 + # pkg:gem/rubocop#lib/rubocop/options.rb:273 def add_additional_modes(opts); end # the autocorrect command-line arguments map to the autocorrect @options values like so: @@ -64968,79 +66623,85 @@ class RuboCop::Options # --safe-auto-correct - true true - # -A, --auto-correct-all - true - true # - # pkg:gem/rubocop#lib/rubocop/options.rb:161 + # pkg:gem/rubocop#lib/rubocop/options.rb:174 def add_autocorrection_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:230 + # pkg:gem/rubocop#lib/rubocop/options.rb:243 def add_cache_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:86 + # pkg:gem/rubocop#lib/rubocop/options.rb:93 def add_check_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:186 + # pkg:gem/rubocop#lib/rubocop/options.rb:199 def add_config_generation_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:206 + # pkg:gem/rubocop#lib/rubocop/options.rb:219 def add_cop_selection_csv_option(option, opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:273 + # pkg:gem/rubocop#lib/rubocop/options.rb:289 def add_general_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:237 + # pkg:gem/rubocop#lib/rubocop/options.rb:250 def add_lsp_option(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:243 + # pkg:gem/rubocop#lib/rubocop/options.rb:256 def add_mcp_option(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:125 + # pkg:gem/rubocop#lib/rubocop/options.rb:135 def add_output_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:286 + # pkg:gem/rubocop#lib/rubocop/options.rb:302 def add_profile_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:249 + # pkg:gem/rubocop#lib/rubocop/options.rb:262 def add_server_options(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:221 + # pkg:gem/rubocop#lib/rubocop/options.rb:234 def add_severity_option(opts); end - # pkg:gem/rubocop#lib/rubocop/options.rb:66 + # pkg:gem/rubocop#lib/rubocop/options.rb:73 def define_options; end - # pkg:gem/rubocop#lib/rubocop/options.rb:296 + # pkg:gem/rubocop#lib/rubocop/options.rb:312 def handle_deprecated_option(old_option, new_option); end # `--diff` is a dry run of autocorrection, so it turns autocorrection on # unless the user already picked a mode with `-a`, `-A` or `-x`. # - # pkg:gem/rubocop#lib/rubocop/options.rb:58 + # pkg:gem/rubocop#lib/rubocop/options.rb:65 def imply_autocorrect_for_diff; end # Finds the option in `args` starting with -- and converts it to a symbol, # e.g. [..., '--autocorrect', ...] to :autocorrect. # - # pkg:gem/rubocop#lib/rubocop/options.rb:330 + # pkg:gem/rubocop#lib/rubocop/options.rb:346 def long_opt_symbol(args); end # Sets a value in the @options hash, based on the given long option and its # value, in addition to calling the block if a block is given. # - # pkg:gem/rubocop#lib/rubocop/options.rb:319 + # pkg:gem/rubocop#lib/rubocop/options.rb:335 def option(opts, *args); end - # pkg:gem/rubocop#lib/rubocop/options.rb:335 + # pkg:gem/rubocop#lib/rubocop/options.rb:351 def plugin_feature(file); end - # pkg:gem/rubocop#lib/rubocop/options.rb:301 + # pkg:gem/rubocop#lib/rubocop/options.rb:317 def rainbow; end - # pkg:gem/rubocop#lib/rubocop/options.rb:341 + # pkg:gem/rubocop#lib/rubocop/options.rb:357 def require_feature(file); end + # `--changed lib` hands the path to `--changed` as its optional argument, + # so it goes back among the paths to inspect. + # + # pkg:gem/rubocop#lib/rubocop/options.rb:59 + def return_path_given_to_changed(args); end + # Creates a section of options in order to separate them visually when # using `--help`. # - # pkg:gem/rubocop#lib/rubocop/options.rb:311 + # pkg:gem/rubocop#lib/rubocop/options.rb:327 def section(opts, heading, &_block); end end @@ -65056,102 +66717,107 @@ RuboCop::Options::E_STDIN_NO_PATH = T.let(T.unsafe(nil), String) # This module contains help texts for command line options. # @api private # -# pkg:gem/rubocop#lib/rubocop/options.rb:577 +# pkg:gem/rubocop#lib/rubocop/options.rb:603 module RuboCop::OptionsHelp; end -# pkg:gem/rubocop#lib/rubocop/options.rb:579 +# pkg:gem/rubocop#lib/rubocop/options.rb:605 RuboCop::OptionsHelp::FORMATTER_OPTION_LIST = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/options.rb:578 +# pkg:gem/rubocop#lib/rubocop/options.rb:604 RuboCop::OptionsHelp::MAX_EXCL = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/options.rb:581 +# pkg:gem/rubocop#lib/rubocop/options.rb:607 RuboCop::OptionsHelp::TEXT = T.let(T.unsafe(nil), Hash) # Validates option arguments and the options' compatibility with each other. # @api private # -# pkg:gem/rubocop#lib/rubocop/options.rb:359 +# pkg:gem/rubocop#lib/rubocop/options.rb:375 class RuboCop::OptionsValidator - # pkg:gem/rubocop#lib/rubocop/options.rb:397 + # pkg:gem/rubocop#lib/rubocop/options.rb:413 def initialize(options); end - # pkg:gem/rubocop#lib/rubocop/options.rb:540 + # pkg:gem/rubocop#lib/rubocop/options.rb:558 def boolean_or_empty_cache?; end - # pkg:gem/rubocop#lib/rubocop/options.rb:511 + # pkg:gem/rubocop#lib/rubocop/options.rb:527 def disable_parallel_when_invalid_option_combo; end - # pkg:gem/rubocop#lib/rubocop/options.rb:536 + # pkg:gem/rubocop#lib/rubocop/options.rb:554 def except_syntax?; end - # pkg:gem/rubocop#lib/rubocop/options.rb:544 + # pkg:gem/rubocop#lib/rubocop/options.rb:562 def incompatible_options; end - # pkg:gem/rubocop#lib/rubocop/options.rb:524 + # pkg:gem/rubocop#lib/rubocop/options.rb:542 def invalid_arguments_for_parallel; end - # pkg:gem/rubocop#lib/rubocop/options.rb:531 + # pkg:gem/rubocop#lib/rubocop/options.rb:549 def only_includes_redundant_disable?; end - # pkg:gem/rubocop#lib/rubocop/options.rb:431 + # OptionParser hands `--changed lib/` the path as the revision, which is a + # natural thing to type, so an argument that names an existing path is + # taken as one. When it also names a revision there is no telling which + # was meant, and git itself refuses such an argument as ambiguous. + # + # pkg:gem/rubocop#lib/rubocop/options.rb:570 + def path_given_to_changed?(revision); end + + # pkg:gem/rubocop#lib/rubocop/options.rb:447 def validate_auto_gen_config; end - # pkg:gem/rubocop#lib/rubocop/options.rb:497 + # pkg:gem/rubocop#lib/rubocop/options.rb:513 def validate_autocorrect; end - # pkg:gem/rubocop#lib/rubocop/options.rb:567 + # pkg:gem/rubocop#lib/rubocop/options.rb:593 def validate_cache_enabled_for_cache_root; end - # pkg:gem/rubocop#lib/rubocop/options.rb:478 + # pkg:gem/rubocop#lib/rubocop/options.rb:494 def validate_changed_and_stdin; end - # OptionParser hands `--changed lib/` the path as the revision, which is a - # natural thing to type, so point at the fix rather than at git's error. - # - # pkg:gem/rubocop#lib/rubocop/options.rb:550 - def validate_changed_revision(revision); end - - # pkg:gem/rubocop#lib/rubocop/options.rb:406 + # pkg:gem/rubocop#lib/rubocop/options.rb:422 def validate_compatibility; end - # pkg:gem/rubocop#lib/rubocop/options.rb:401 + # pkg:gem/rubocop#lib/rubocop/options.rb:417 def validate_cop_options; end # `--diff` promises not to write anything, and `--auto-gen-config` exists to # write a file. # - # pkg:gem/rubocop#lib/rubocop/options.rb:472 + # pkg:gem/rubocop#lib/rubocop/options.rb:488 def validate_diff; end - # pkg:gem/rubocop#lib/rubocop/options.rb:452 + # pkg:gem/rubocop#lib/rubocop/options.rb:468 def validate_display_only_correctable_and_autocorrect; end - # pkg:gem/rubocop#lib/rubocop/options.rb:444 + # pkg:gem/rubocop#lib/rubocop/options.rb:460 def validate_display_only_failed; end - # pkg:gem/rubocop#lib/rubocop/options.rb:461 + # pkg:gem/rubocop#lib/rubocop/options.rb:477 def validate_display_only_failed_and_display_only_correctable; end - # pkg:gem/rubocop#lib/rubocop/options.rb:490 + # pkg:gem/rubocop#lib/rubocop/options.rb:506 def validate_enable_all_cops_and_disable_all_cops; end - # pkg:gem/rubocop#lib/rubocop/options.rb:559 + # pkg:gem/rubocop#lib/rubocop/options.rb:585 def validate_exclude_limit_option; end - # pkg:gem/rubocop#lib/rubocop/options.rb:484 + # pkg:gem/rubocop#lib/rubocop/options.rb:500 def validate_lsp_and_editor_mode; end + # pkg:gem/rubocop#lib/rubocop/options.rb:579 + def validate_max_offenses_per_cop_option; end + class << self # Cop name validation must be done later than option parsing, so it's not # called from within Options. # - # pkg:gem/rubocop#lib/rubocop/options.rb:366 + # pkg:gem/rubocop#lib/rubocop/options.rb:382 def validate_cop_list(names); end private - # pkg:gem/rubocop#lib/rubocop/options.rb:383 + # pkg:gem/rubocop#lib/rubocop/options.rb:399 def format_message_from(name, cop_names); end end end @@ -65358,10 +67024,10 @@ class RuboCop::Plugin::ConfigurationIntegrator # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:27 def create_context(rubocop_config); end - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:85 + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:92 def fake_out_rubocop_default_configuration(default_config); end - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:96 + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:103 def load_plugin_rubocop_config(plugin, runner_context); end # This is how we ensure "first-in wins": plugins can override AllCops settings that are @@ -65373,16 +67039,25 @@ class RuboCop::Plugin::ConfigurationIntegrator # new`) to allow plugins to add to the array, for example Include and # Exclude paths and patterns. # - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:121 + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:128 def merge_all_cop_settings(existing_all_cops, new_all_cops, already_configured_keys); end - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:71 + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:78 def merge_plugin_config_into_all_cops!(rubocop_config, plugin_config); end - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:75 + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:82 def merge_plugin_config_into_default_config!(default_config, plugin_config); end - # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:140 + # `unset_nil: false` keeps `AllCops` keys declared with a nil value by a plugin + # (e.g. `TargetRailsVersion: ~` of rubocop-rails); `merge_all_cop_settings` carries + # such keys into each subsequent plugin's config, where `unset_nil: true` would + # delete them from the combined configuration. Preview is left to be applied when + # a project configuration is resolved against the defaults. + # + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:72 + def merge_plugin_config_with_default(plugin_config, plugin_config_path); end + + # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:147 def resolver; end # pkg:gem/rubocop#lib/rubocop/plugin/configuration_integrator.rb:37 @@ -65632,25 +67307,25 @@ class RuboCop::RemoteConfig private - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:100 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:103 def cache_name_from_uri; end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:83 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:86 def cache_path; end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:87 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:90 def cache_path_exists?; end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:91 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:94 def cache_path_expired?; end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:107 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:110 def cloned_url; end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:58 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:61 def generate_request(uri); end - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:67 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:70 def handle_response(response, uri, limit, &block); end # pkg:gem/rubocop#lib/rubocop/remote_config.rb:45 @@ -65685,7 +67360,7 @@ class RuboCop::ResultCache private - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:169 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:160 def any_symlink?(path); end # We combine team and options into a single "context" checksum to avoid @@ -65693,22 +67368,25 @@ class RuboCop::ResultCache # This context is for anything that's not (1) the RuboCop executable # checksum or (2) the inspected file checksum. # - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:267 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:274 def context_checksum(team, options); end - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:180 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:187 def file_checksum(file, config_store); end - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:165 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:156 def symlink_protection_triggered?(path); end # Every file that fails to checksum shares this sentinel value, so the cache entry # must be neither saved nor considered valid, or one file's cached results could be # served as another's. # - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:196 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:203 def unavailable_checksum; end + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:171 + def write_cache_file(offenses); end + class << self # pkg:gem/rubocop#lib/rubocop/result_cache.rb:98 def allow_symlinks_in_cache_location?(config_store); end @@ -65726,17 +67404,17 @@ class RuboCop::ResultCache # pkg:gem/rubocop#lib/rubocop/result_cache.rb:28 def cleanup(config_store, verbose, cache_root_override = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:202 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:209 def inhibit_cleanup; end - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:202 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:209 def inhibit_cleanup=(_arg0); end # Return a hash of the options given at invocation, minus the ones that have # no effect on which offenses and disabled line ranges are found, and thus # don't affect caching. # - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:222 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:229 def relevant_options_digest(options); end # pkg:gem/rubocop#lib/rubocop/result_cache.rb:102 @@ -65754,12 +67432,12 @@ class RuboCop::ResultCache # The checksum of the RuboCop program running the inspection. # - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:205 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:212 def source_checksum; end private - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:232 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:239 def digest(path); end # pkg:gem/rubocop#lib/rubocop/result_cache.rb:68 @@ -65771,7 +67449,7 @@ class RuboCop::ResultCache # pkg:gem/rubocop#lib/rubocop/result_cache.rb:51 def requires_file_removal?(file_count, config_store); end - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:243 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:250 def rubocop_extra_features; end end end @@ -65793,16 +67471,20 @@ class RuboCop::Runner # pkg:gem/rubocop#lib/rubocop/runner.rb:57 def aborting=(_arg0); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:93 + # pkg:gem/rubocop#lib/rubocop/runner.rb:103 def aborting?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:56 + # The `--diff` patches, one per file, from the source on disk (or stdin) to + # the source once every correction, redundant directive removal included, + # has been applied. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:73 def diffs; end # pkg:gem/rubocop#lib/rubocop/runner.rb:56 def errors; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:70 + # pkg:gem/rubocop#lib/rubocop/runner.rb:80 def run(paths); end # pkg:gem/rubocop#lib/rubocop/runner.rb:56 @@ -65810,166 +67492,190 @@ class RuboCop::Runner private - # pkg:gem/rubocop#lib/rubocop/runner.rb:317 + # pkg:gem/rubocop#lib/rubocop/runner.rb:345 def add_redundant_disables(file, offenses, source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:701 + # pkg:gem/rubocop#lib/rubocop/runner.rb:769 def assemble_team(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:120 + # pkg:gem/rubocop#lib/rubocop/runner.rb:128 def build_project_index(target_files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:142 + # pkg:gem/rubocop#lib/rubocop/runner.rb:150 def bundled_gem_files; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:291 + # pkg:gem/rubocop#lib/rubocop/runner.rb:319 def cached_result(file, team); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:378 + # pkg:gem/rubocop#lib/rubocop/runner.rb:419 def cached_run?; end # Check whether a run created source identical to a previous run, which # means that we definitely have an infinite loop. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:518 + # pkg:gem/rubocop#lib/rubocop/runner.rb:559 def check_for_infinite_loop(processed_source, offenses_by_iteration); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:343 + # pkg:gem/rubocop#lib/rubocop/runner.rb:375 def check_for_redundant_disables?(source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:611 + # Keeps the errors and warnings a file causes apart from the rest of the + # run's. A parallel worker inspects files in a copy of the runner that is + # thrown away, so they have to travel back with the file's offenses. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:288 + def collect_problems; end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:658 def considered_failure?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:648 + # pkg:gem/rubocop#lib/rubocop/runner.rb:716 def default_config(cop_name); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:396 - def do_inspection_loop(file); end - - # When corrections were written to disk and read back between iterations, - # the text-mode write converted LF to CRLF on Windows, and cops like - # `Layout/EndOfLine` rely on seeing the source as it would be on disk. - # Apply the same conversion to the in-memory source. The final `File.write` - # still performs it for the file itself. - # - # pkg:gem/rubocop#lib/rubocop/runner.rb:480 - def emulate_write_read_cycle(source); end + # pkg:gem/rubocop#lib/rubocop/runner.rb:438 + def do_inspection_loop(file, source = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:363 + # pkg:gem/rubocop#lib/rubocop/runner.rb:395 def except_redundant_cop_disable_directive?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:540 + # pkg:gem/rubocop#lib/rubocop/runner.rb:581 def extract_ruby_sources(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:372 + # pkg:gem/rubocop#lib/rubocop/runner.rb:413 def file_finished(file, offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:178 + # pkg:gem/rubocop#lib/rubocop/runner.rb:188 def file_iterator(files, &block); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:295 + # pkg:gem/rubocop#lib/rubocop/runner.rb:323 def file_offense_cache(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:282 + # pkg:gem/rubocop#lib/rubocop/runner.rb:310 def file_offenses(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:367 + # Formatters get the messages without the colors added for the terminal. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:405 + def file_problems(file, errors, warnings); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:399 def file_started(file); end # Write the file once, even when the loop was left through an exception # (e.g. an infinite correction loop), like the per-iteration writes used # to be. Under `--diff` nothing is written at all. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:444 + # pkg:gem/rubocop#lib/rubocop/runner.rb:494 def finalize_corrections(file, original_source, corrected_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:109 + # pkg:gem/rubocop#lib/rubocop/runner.rb:117 def find_target_files(paths); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:198 - def finished_report(file, index, offenses); end + # pkg:gem/rubocop#lib/rubocop/runner.rb:208 + def finished_report(file, index, offenses, problems); end + + # Lets a runner that is reused from run to run pick up a different `--only` + # or `--except`. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:619 + def forget_mobilized_cops; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:602 + # pkg:gem/rubocop#lib/rubocop/runner.rb:649 def formatter_set; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:658 + # pkg:gem/rubocop#lib/rubocop/runner.rb:726 def get_processed_source(file, prism_result, source: T.unsafe(nil)); end # Custom ruby extractors may derive their fragments from the file on # disk rather than from the passed processed source, so corrections can # only be kept in memory when the default extractor is used. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:489 + # pkg:gem/rubocop#lib/rubocop/runner.rb:530 def in_memory_corrections_possible?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:431 + # `source` is the corrected source to continue from when the corrections + # are kept in memory rather than written to the file (`--diff`). + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:474 + def initial_processed_source(file, source); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:481 def inspect_and_correct(processed_source, offenses_by_iteration); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:532 + # pkg:gem/rubocop#lib/rubocop/runner.rb:573 def inspect_file(processed_source, team = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:159 + # pkg:gem/rubocop#lib/rubocop/runner.rb:167 def inspect_files(files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:468 + # pkg:gem/rubocop#lib/rubocop/runner.rb:520 def inspect_iteration(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:493 + # pkg:gem/rubocop#lib/rubocop/runner.rb:534 def iterate_until_no_changes(source, offenses_by_iteration); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:268 + # pkg:gem/rubocop#lib/rubocop/runner.rb:281 def list_files(paths); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:644 + # pkg:gem/rubocop#lib/rubocop/runner.rb:712 def mark_as_safe_by_config?(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:652 + # pkg:gem/rubocop#lib/rubocop/runner.rb:720 def minimum_severity_to_fail; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:576 + # pkg:gem/rubocop#lib/rubocop/runner.rb:623 def mobilize_cop_badge?(badge, config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:554 + # pkg:gem/rubocop#lib/rubocop/runner.rb:595 def mobilize_team(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:560 + # pkg:gem/rubocop#lib/rubocop/runner.rb:601 def mobilized_cop_classes(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:620 + # pkg:gem/rubocop#lib/rubocop/runner.rb:667 def offense_displayed?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:632 + # Files are reported in order, so which offenses survive the limit does not + # depend on how the run was parallelized. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:687 + def offense_limit; end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:679 def offenses_to_report(offenses); end # The project index is deliberately built from the unfiltered file list: # cross-file offenses must not depend on which files happen to have changed. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:101 + # pkg:gem/rubocop#lib/rubocop/runner.rb:111 def only_changed(target_files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:251 + # pkg:gem/rubocop#lib/rubocop/runner.rb:264 def parallel_file_iterator(files, on_start, on_finish, &block); end # `--auto-gen-config` needs the offenses of every file in one place, and # `--diff` collects the diffs in this process, where a worker's copy of # them would be lost. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:236 + # pkg:gem/rubocop#lib/rubocop/runner.rb:249 def parallel_supported_by_options?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:272 + # pkg:gem/rubocop#lib/rubocop/runner.rb:409 + def plain_messages(problems); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:300 def process_file(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:212 + # pkg:gem/rubocop#lib/rubocop/runner.rb:225 def process_remaining_report_queue; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:207 + # pkg:gem/rubocop#lib/rubocop/runner.rb:217 def process_report_queue_entry(index); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:240 + # pkg:gem/rubocop#lib/rubocop/runner.rb:253 def project_index_disables_parallel?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:148 + # pkg:gem/rubocop#lib/rubocop/runner.rb:156 def project_index_enabled?; end # The index always covers the whole project, not just the files being @@ -65978,29 +67684,31 @@ class RuboCop::Runner # sharding) would see different offenses than full runs. The project is # rooted at the directory of the configuration that enabled the index. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:131 + # pkg:gem/rubocop#lib/rubocop/runner.rb:139 def project_index_files(target_files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:588 + # pkg:gem/rubocop#lib/rubocop/runner.rb:635 def qualify_option_cop_names; end # `--diff` reports what autocorrection would do instead of doing it. With # `--stdin` the corrected source is handed back through the options rather - # than deferred, so that is where the new source comes from. + # than deferred, so that is where the new source comes from. A file can go + # through more than one inspection loop, so the diff runs from the source + # the first loop started with to the one the last loop ended with. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:455 + # pkg:gem/rubocop#lib/rubocop/runner.rb:507 def record_diff(file, original_source, corrected_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:355 + # pkg:gem/rubocop#lib/rubocop/runner.rb:387 def redundant_cop_disable_directive(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:218 + # pkg:gem/rubocop#lib/rubocop/runner.rb:231 def run_in_parallel?(files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:386 + # pkg:gem/rubocop#lib/rubocop/runner.rb:427 def save_in_cache(cache, offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:255 + # pkg:gem/rubocop#lib/rubocop/runner.rb:268 def serial_file_iterator(files, on_start, on_finish, &block); end # A Cop::Team instance is stateful and may change when inspecting. @@ -66008,18 +67716,21 @@ class RuboCop::Runner # otherwise dormant team that can be used for config- and option- # level caching in ResultCache. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:696 + # pkg:gem/rubocop#lib/rubocop/runner.rb:764 def standby_team(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:598 + # pkg:gem/rubocop#lib/rubocop/runner.rb:645 def style_guide_cops_only?(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:636 + # pkg:gem/rubocop#lib/rubocop/runner.rb:704 def supports_safe_autocorrect?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:332 + # pkg:gem/rubocop#lib/rubocop/runner.rb:362 def team_for_redundant_disables(file, offenses, source); end + # pkg:gem/rubocop#lib/rubocop/runner.rb:694 + def warn_about_elided_offenses; end + class << self # @return [Array<#call>] # @@ -66621,8 +68332,39 @@ RuboCop::UnifiedDiff::NO_NEWLINE_MARKER = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/util.rb:5 module RuboCop::Util class << self + # The source as it reads back after `File.write`, which in text mode turns + # each LF into CRLF on Windows. Cops like `Layout/EndOfLine` have to see + # corrected code that way between correction passes, and so does anything + # that compares it with what a write leaves on disk. The final `File.write` + # still performs the conversion for the file itself. + # + # pkg:gem/rubocop#lib/rubocop/util.rb:21 + def emulate_write_read_cycle(source); end + + # Replaces the contents of `path` without a window in which the file is truncated + # but not yet rewritten, so that an interrupted run or a full disk cannot lose + # the original: the new contents are written next to the file and renamed over it, + # like `ResultCache#save`. `File.write` is used for the temporary file so text-mode + # semantics (the CRLF conversion on Windows) stay identical to a direct write. + # Where the temporary file cannot be created or renamed for lack of permission, + # a direct write is used as before. + # + # pkg:gem/rubocop#lib/rubocop/util.rb:34 + def replace_file_contents(path, contents); end + # pkg:gem/rubocop#lib/rubocop/util.rb:6 def silence_warnings; end + + private + + # pkg:gem/rubocop#lib/rubocop/util.rb:55 + def replace_via_temporary_file(path, temp_path, contents); end + + # Space errors such as `ENOSPC` must propagate: a direct write would then + # truncate the file and fail, which is exactly the loss being avoided. + # + # pkg:gem/rubocop#lib/rubocop/util.rb:77 + def write_temporary_file(temp_path, contents); end end end diff --git a/sorbet/rbi/gems/spoom@1.8.9.rbi b/sorbet/rbi/gems/spoom@1.8.12.rbi similarity index 96% rename from sorbet/rbi/gems/spoom@1.8.9.rbi rename to sorbet/rbi/gems/spoom@1.8.12.rbi index 03c6cfeb6..67af8edbc 100644 --- a/sorbet/rbi/gems/spoom@1.8.9.rbi +++ b/sorbet/rbi/gems/spoom@1.8.12.rbi @@ -76,7 +76,7 @@ class Spoom::Cli::Deadcode < ::Thor # pkg:gem/spoom#lib/spoom/cli.rb:71 def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end - # pkg:gem/spoom#lib/spoom/cli/deadcode.rb:153 + # pkg:gem/spoom#lib/spoom/cli/deadcode.rb:164 def remove(location_string); end end @@ -263,19 +263,19 @@ class Spoom::Cli::Srb::Coverage < ::Thor include ::Spoom::Colorize include ::Spoom::Cli::Helper - # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:199 + # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:202 def bundle_install(path, sha); end # pkg:gem/spoom#lib/spoom/cli/srb.rb:23 def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end - # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:211 + # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:214 def message_no_data(file); end - # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:174 + # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:177 def open(file = T.unsafe(nil)); end - # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:190 + # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:193 def parse_time(string, option); end # pkg:gem/spoom#lib/spoom/cli/srb/coverage.rb:143 @@ -1095,39 +1095,56 @@ end class Spoom::Coverage::D3::Base abstract! - # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:13 + # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:16 sig { params(id: ::String, data: T.untyped).void } def initialize(id, data); end - # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:31 + # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:34 sig { returns(::String) } def html; end - # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:10 + # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:13 sig { returns(::String) } def id; end # @abstract # - # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:45 + # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:48 sig { abstract.returns(::String) } def script; end - # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:39 + # pkg:gem/spoom#lib/spoom/coverage/d3/base.rb:42 sig { returns(::String) } def tooltip; end + private + + # Serialize `value` as a JavaScript literal that is safe to embed in a ``. We also escape `<`, `>` and `&` + # so the data can't contain `