language stringclasses 1
value | owner stringlengths 2 15 | repo stringlengths 2 21 | sha stringlengths 45 45 | message stringlengths 7 36.3k | path stringlengths 1 199 | patch stringlengths 15 102k | is_multipart bool 2
classes |
|---|---|---|---|---|---|---|---|
Other | Homebrew | brew | 369fa8d838b180b7e65fd548c7e011f29a40eaa4.json | Update RBI files for sorbet-static-and-runtime. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -2995,17 +2995,9 @@ module Kernel
def choose(*args, &block); end
- def itself(); end
-
- def object_id(); end
-
def pretty_inspect(); end
def say(*args, &block); end
-
- def then(); end
-
- def yield_self(); end
end
module Kernel | false |
Other | Homebrew | brew | c6907f911f12cff4374d78a6f080721675e1d232.json | Sparkle: Provide channel information in Item
Making `channel` information available in the `Item` is necessary
to be able to filter out unstable items using a `strategy` block. If
an item doesn't specify a channel, then it uses the default channel
(this is what Sparkle itself uses for updates). Channels like `beta`
are something we want to avoid for stable casks and this allows for
that type of [cask-specific] filtering.
It's technically possible to automatically filter out items that
aren't using the default channel (i.e., `channel != nil`) in
`#items_from_content` but some casks use an unstable version, so we
can't do this internally. That is to say, we wouldn't be able to
override internal filtering in a `strategy` block, as any omitted
items wouldn't be provided to the block. Conversely, if we pass all
items to a `strategy` block, we can easily filter by channel there.
We haven't been filtering by channel internally and we've only found
one cask where this has been a problem, so it seems fine for now. | Library/Homebrew/livecheck/strategy/sparkle.rb | @@ -36,6 +36,8 @@ def self.match?(url)
Item = Struct.new(
# @api public
:title,
+ # @api public
+ :channel,
# @api private
:pub_date,
# @api public
@@ -102,6 +104,7 @@ def self.items_from_content(content)
os = enclosure["os"]
end
+ channel = item.elements["channel"]&.text
url ||= item.elements["link"]&.text
short_version ||= item.elements["shortVersionString"]&.text&.strip
version ||= item.elements["version"]&.text&.strip
@@ -135,6 +138,7 @@ def self.items_from_content(content)
data = {
title: title,
+ channel: channel,
pub_date: pub_date,
url: url,
bundle_version: bundle_version, | true |
Other | Homebrew | brew | c6907f911f12cff4374d78a6f080721675e1d232.json | Sparkle: Provide channel information in Item
Making `channel` information available in the `Item` is necessary
to be able to filter out unstable items using a `strategy` block. If
an item doesn't specify a channel, then it uses the default channel
(this is what Sparkle itself uses for updates). Channels like `beta`
are something we want to avoid for stable casks and this allows for
that type of [cask-specific] filtering.
It's technically possible to automatically filter out items that
aren't using the default channel (i.e., `channel != nil`) in
`#items_from_content` but some casks use an unstable version, so we
can't do this internally. That is to say, we wouldn't be able to
override internal filtering in a `strategy` block, as any omitted
items wouldn't be provided to the block. Conversely, if we pass all
items to a `strategy` block, we can easily filter by channel there.
We haven't been filtering by channel internally and we've only found
one cask where this has been a problem, so it seems fine for now. | Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb | @@ -75,6 +75,13 @@
EOS
appcast_with_omitted_items = appcast_xml.sub("</item>", "</item>\n#{extra_items}")
+ beta_channel_item = appcast_xml.sub(
+ first_item,
+ first_item.sub(
+ "</title",
+ "</title>\n<sparkle:channel>beta</sparkle:channel>",
+ ),
+ )
no_versions_item =
appcast_xml
.sub(second_item, "")
@@ -89,6 +96,7 @@
{
appcast: appcast_xml,
appcast_with_omitted_items: appcast_with_omitted_items,
+ beta_channel_item: beta_channel_item,
no_versions_item: no_versions_item,
no_items: no_items,
undefined_namespace: undefined_namespace_xml,
@@ -98,7 +106,7 @@
let(:title_regex) { /Version\s+v?(\d+(?:\.\d+)+)\s*$/i }
let(:items) {
- {
+ items = {
appcast: [
Homebrew::Livecheck::Strategy::Sparkle::Item.new(
title: item_hash[0][:title],
@@ -122,6 +130,12 @@
),
],
}
+
+ beta_channel_item = items[:appcast][0].clone
+ beta_channel_item.channel = "beta"
+ items[:beta_channel_item] = [beta_channel_item, items[:appcast][1].clone]
+
+ items
}
let(:versions) { [items[:appcast][0].nice_version] }
@@ -152,6 +166,7 @@
expect(first_item.short_version).to eq(item_hash[0][:short_version])
expect(first_item.version).to eq(item_hash[0][:version])
+ expect(sparkle.items_from_content(xml[:beta_channel_item])).to eq(items[:beta_channel_item])
expect(sparkle.items_from_content(xml[:no_versions_item])).to eq(items[:no_versions_item])
end
end
@@ -162,6 +177,7 @@
it "returns an array of version strings when given content" do
expect(sparkle.versions_from_content(xml[:appcast])).to eq(versions)
expect(sparkle.versions_from_content(xml[:appcast_with_omitted_items])).to eq(versions)
+ expect(sparkle.versions_from_content(xml[:beta_channel_item])).to eq(versions)
expect(sparkle.versions_from_content(xml[:no_versions_item])).to eq([])
expect(sparkle.versions_from_content(xml[:undefined_namespace])).to eq(versions)
end
@@ -184,6 +200,12 @@
items.map { |item| item.nice_version&.sub("1", "0") }
end,
).to eq(subbed_items)
+
+ expect(
+ sparkle.versions_from_content(xml[:beta_channel_item]) do |items|
+ items.find { |item| item.channel.nil? }&.nice_version
+ end,
+ ).to eq([items[:appcast][1].nice_version])
end
it "returns an array of version strings when given content, a regex, and a block" do | true |
Other | Homebrew | brew | 183cbe00014803eef4e9e3f4f6e87043c1d3b3a3.json | named_args: handle additional cask exception | Library/Homebrew/cli/named_args.rb | @@ -155,7 +155,7 @@ def load_formula_or_cask(name, only: nil, method: nil, prefer_loading_from_api:
end
return cask
- rescue Cask::CaskUnreadableError => e
+ rescue Cask::CaskUnreadableError, Cask::CaskInvalidError => e
# If we're trying to get a keg-like Cask, do our best to handle it
# not being readable and return something that can be used.
if want_keg_like_cask | false |
Other | Homebrew | brew | b4cb47815f10d5914df2c33ccd4ac7ac569743bc.json | Sparkle: Pass all items into strategy block
It's sometimes necessary to work with all the items in a Sparkle feed
to be able to correctly identify the newest version but livecheck's
`Sparkle` strategy only passes the `item` it views as newest into a
`strategy` block.
This updates the `Sparkle` strategy to optionally pass all items into
a `strategy` block, so we can manipulate them (e.g., filtering,
sorting). This is enabled by naming the first argument of the
strategy block `items` instead of `item`. `Sparkle` `strategy` blocks
where the first argument is `item` will continue to work as expected.
This necessarily updates `#item_from_content` (now
`items_from_content`) to return all items. I've decided to move the
sorting out of `#items_from_content`, so it simply returns the items
in the order they appear. If there is ever an exceptional situation
where we need the original order, this will technically allow for it.
The sorting has instead been moved into the `#versions_from_content`
method, to maintain the existing behavior. I thought about passing
the items into the `strategy` block in their original order but it
feels like sorting by default is the better approach for now (partly
from the perspective of maintaining existing behavior) and we can
always revisit this in the future if a cask ever requires the
original order.
Lastly, this expands the `Sparkle` tests to increase coverage. The
only untested parts are `#find_versions` (which currently
requires a network request) and a couple safeguard `raise` calls
when there's a `REXML::UndefinedNamespaceException` (which shouldn't
be encountered unless something is broken). | Library/Homebrew/livecheck/strategy/sparkle.rb | @@ -53,14 +53,17 @@ def self.match?(url)
# @api public
delegate short_version: :bundle_version
+
+ # @api public
+ delegate nice_version: :bundle_version
end
# Identify version information from a Sparkle appcast.
#
# @param content [String] the text of the Sparkle appcast
# @return [Item, nil]
- sig { params(content: String).returns(T.nilable(Item)) }
- def self.item_from_content(content)
+ sig { params(content: String).returns(T::Array[Item]) }
+ def self.items_from_content(content)
require "rexml/document"
parsing_tries = 0
@@ -75,8 +78,8 @@ def self.item_from_content(content)
raise if parsing_tries > 1
# When an XML document contains a prefix without a corresponding
- # namespace, it's necessary to remove the the prefix from the
- # content to be able to successfully parse it using REXML
+ # namespace, it's necessary to remove the prefix from the content
+ # to be able to successfully parse it using REXML
content = content.gsub(%r{(</?| )#{Regexp.escape(undefined_prefix)}:}, '\1')
retry
end
@@ -89,7 +92,7 @@ def self.item_from_content(content)
end
end
- items = xml.get_elements("//rss//channel//item").map do |item|
+ xml.get_elements("//rss//channel//item").map do |item|
enclosure = item.elements["enclosure"]
if enclosure
@@ -132,15 +135,17 @@ def self.item_from_content(content)
data = {
title: title,
- pub_date: pub_date || Time.new(0),
+ pub_date: pub_date,
url: url,
bundle_version: bundle_version,
}.compact
+ next if data.empty?
- Item.new(**data) unless data.empty?
- end.compact
+ # Set a default `pub_date` (for sorting) if one isn't provided
+ data[:pub_date] ||= Time.new(0)
- items.max_by { |item| [item.pub_date, item.bundle_version] }
+ Item.new(**data)
+ end.compact
end
# Identify versions from content
@@ -155,15 +160,24 @@ def self.item_from_content(content)
).returns(T::Array[String])
}
def self.versions_from_content(content, regex = nil, &block)
- item = item_from_content(content)
- return [] if item.blank?
+ items = items_from_content(content).sort_by { |item| [item.pub_date, item.bundle_version] }.reverse
+ return [] if items.blank?
+
+ item = items.first
if block
- block_return_value = regex.present? ? yield(item, regex) : yield(item)
+ block_return_value = case block.parameters[0]
+ when [:opt, :item], [:rest]
+ regex.present? ? yield(item, regex) : yield(item)
+ when [:opt, :items]
+ regex.present? ? yield(items, regex) : yield(items)
+ else
+ raise "First argument of Sparkle `strategy` block must be `item` or `items`"
+ end
return Strategy.handle_block_return(block_return_value)
end
- version = item.bundle_version&.nice_version
+ version = T.must(item).bundle_version&.nice_version
version.present? ? [version] : []
end
| true |
Other | Homebrew | brew | b4cb47815f10d5914df2c33ccd4ac7ac569743bc.json | Sparkle: Pass all items into strategy block
It's sometimes necessary to work with all the items in a Sparkle feed
to be able to correctly identify the newest version but livecheck's
`Sparkle` strategy only passes the `item` it views as newest into a
`strategy` block.
This updates the `Sparkle` strategy to optionally pass all items into
a `strategy` block, so we can manipulate them (e.g., filtering,
sorting). This is enabled by naming the first argument of the
strategy block `items` instead of `item`. `Sparkle` `strategy` blocks
where the first argument is `item` will continue to work as expected.
This necessarily updates `#item_from_content` (now
`items_from_content`) to return all items. I've decided to move the
sorting out of `#items_from_content`, so it simply returns the items
in the order they appear. If there is ever an exceptional situation
where we need the original order, this will technically allow for it.
The sorting has instead been moved into the `#versions_from_content`
method, to maintain the existing behavior. I thought about passing
the items into the `strategy` block in their original order but it
feels like sorting by default is the better approach for now (partly
from the perspective of maintaining existing behavior) and we can
always revisit this in the future if a cask ever requires the
original order.
Lastly, this expands the `Sparkle` tests to increase coverage. The
only untested parts are `#find_versions` (which currently
requires a network request) and a couple safeguard `raise` calls
when there's a `REXML::UndefinedNamespaceException` (which shouldn't
be encountered unless something is broken). | Library/Homebrew/test/livecheck/strategy/sparkle_spec.rb | @@ -10,49 +10,121 @@
let(:appcast_url) { "https://www.example.com/example/appcast.xml" }
let(:non_http_url) { "ftp://brew.sh/" }
- let(:appcast_data) {
- {
- title: "Version 1.2.3",
- pub_date: "Fri, 01 Jan 2021 01:23:45 +0000",
- url: "https://www.example.com/example/example.tar.gz",
- short_version: "1.2.3",
- version: "1234",
- }
+ let(:item_hash) {
+ [
+ {
+ title: "Version 1.2.3",
+ pub_date: "Fri, 01 Jan 2021 01:23:45 +0000",
+ url: "https://www.example.com/example/example-1.2.3.tar.gz",
+ short_version: "1.2.3",
+ version: "123",
+ },
+ {
+ title: "Version 1.2.2",
+ pub_date: "Not a parseable date string",
+ url: "https://www.example.com/example/example-1.2.2.tar.gz",
+ short_version: "1.2.2",
+ version: "122",
+ },
+ ]
}
- let(:appcast_xml) {
- <<~EOS
+ let(:xml) {
+ first_item = <<~EOS
+ <item>
+ <title>#{item_hash[0][:title]}</title>
+ <sparkle:minimumSystemVersion>10.10</sparkle:minimumSystemVersion>
+ <sparkle:releaseNotesLink>https://www.example.com/example/#{item_hash[0][:short_version]}.html</sparkle:releaseNotesLink>
+ <pubDate>#{item_hash[0][:pub_date]}</pubDate>
+ <enclosure url="#{item_hash[0][:url]}" sparkle:shortVersionString="#{item_hash[0][:short_version]}" sparkle:version="#{item_hash[0][:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
+ </item>
+ EOS
+
+ second_item = <<~EOS
+ <item>
+ <title>#{item_hash[1][:title]}</title>
+ <sparkle:minimumSystemVersion>10.10</sparkle:minimumSystemVersion>
+ <sparkle:releaseNotesLink>https://www.example.com/example/#{item_hash[1][:short_version]}.html</sparkle:releaseNotesLink>
+ <pubDate>#{item_hash[1][:pub_date]}</pubDate>
+ <sparkle:version>#{item_hash[1][:version]}</sparkle:version>
+ <sparkle:shortVersionString>#{item_hash[1][:short_version]}</sparkle:shortVersionString>
+ <link>#{item_hash[1][:url]}</link>
+ </item>
+ EOS
+
+ appcast_xml = <<~EOS
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle">
<channel>
<title>Example Changelog</title>
<link>#{appcast_url}</link>
<description>Most recent changes with links to updates.</description>
<language>en</language>
- <item>
- <title>#{appcast_data[:title]}</title>
- <sparkle:minimumSystemVersion>10.10</sparkle:minimumSystemVersion>
- <sparkle:releaseNotesLink>https://www.example.com/example/1.2.3.html</sparkle:releaseNotesLink>
- <pubDate>#{appcast_data[:pub_date]}</pubDate>
- <enclosure url="#{appcast_data[:url]}" sparkle:shortVersionString="#{appcast_data[:short_version]}" sparkle:version="#{appcast_data[:version]}" length="12345678" type="application/octet-stream" sparkle:dsaSignature="ABCDEF+GHIJKLMNOPQRSTUVWXYZab/cdefghijklmnopqrst/uvwxyz1234567==" />
- </item>
+ #{first_item}
+ #{second_item}
</channel>
</rss>
EOS
+
+ extra_items = <<~EOS
+ #{first_item.sub(%r{<(enclosure[^>]+?)\s*?/>}, '<\1 os="not-osx" />')}
+ #{first_item.sub(/(<sparkle:minimumSystemVersion>)[^<]+?</m, '\1100<')}
+ #{first_item.sub(/(<sparkle:minimumSystemVersion>)[^<]+?</m, '\19000<')}
+ <item>
+ </item>
+ EOS
+
+ appcast_with_omitted_items = appcast_xml.sub("</item>", "</item>\n#{extra_items}")
+ no_versions_item =
+ appcast_xml
+ .sub(second_item, "")
+ .gsub(/sparkle:(shortVersionString|version)="[^"]+?"\s*/, "")
+ .sub(
+ "<title>#{item_hash[0][:title]}</title>",
+ "<title>Version</title>",
+ )
+ no_items = appcast_xml.sub(%r{<item>.+</item>}m, "")
+ undefined_namespace_xml = appcast_xml.sub(/\s*xmlns:sparkle="[^"]+?"/, "")
+
+ {
+ appcast: appcast_xml,
+ appcast_with_omitted_items: appcast_with_omitted_items,
+ no_versions_item: no_versions_item,
+ no_items: no_items,
+ undefined_namespace: undefined_namespace_xml,
+ }
}
let(:title_regex) { /Version\s+v?(\d+(?:\.\d+)+)\s*$/i }
- let(:item) {
- Homebrew::Livecheck::Strategy::Sparkle::Item.new(
- title: appcast_data[:title],
- pub_date: Time.parse(appcast_data[:pub_date]),
- url: appcast_data[:url],
- bundle_version: Homebrew::BundleVersion.new(appcast_data[:short_version], appcast_data[:version]),
- )
+ let(:items) {
+ {
+ appcast: [
+ Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+ title: item_hash[0][:title],
+ pub_date: Time.parse(item_hash[0][:pub_date]),
+ url: item_hash[0][:url],
+ bundle_version: Homebrew::BundleVersion.new(item_hash[0][:short_version], item_hash[0][:version]),
+ ),
+ Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+ title: item_hash[1][:title],
+ pub_date: Time.new(0),
+ url: item_hash[1][:url],
+ bundle_version: Homebrew::BundleVersion.new(item_hash[1][:short_version], item_hash[1][:version]),
+ ),
+ ],
+ no_versions_item: [
+ Homebrew::Livecheck::Strategy::Sparkle::Item.new(
+ title: "Version",
+ pub_date: Time.parse(item_hash[0][:pub_date]),
+ url: item_hash[0][:url],
+ bundle_version: nil,
+ ),
+ ],
+ }
}
- let(:versions) { [item.bundle_version.nice_version] }
+ let(:versions) { [items[:appcast][0].nice_version] }
describe "::match?" do
it "returns true for an HTTP URL" do
@@ -64,64 +136,114 @@
end
end
- describe "::item_from_content" do
- let(:item_from_appcast_xml) { sparkle.item_from_content(appcast_xml) }
+ describe "::items_from_content" do
+ let(:items_from_appcast_xml) { sparkle.items_from_content(xml[:appcast]) }
+ let(:first_item) { items_from_appcast_xml[0] }
it "returns nil if content is blank" do
- expect(sparkle.item_from_content("")).to be_nil
+ expect(sparkle.items_from_content("")).to eq([])
end
- it "returns an Item when given XML data" do
- expect(item_from_appcast_xml).to be_a(Homebrew::Livecheck::Strategy::Sparkle::Item)
- expect(item_from_appcast_xml).to eq(item)
- expect(item_from_appcast_xml.title).to eq(appcast_data[:title])
- expect(item_from_appcast_xml.pub_date).to eq(Time.parse(appcast_data[:pub_date]))
- expect(item_from_appcast_xml.url).to eq(appcast_data[:url])
- expect(item_from_appcast_xml.short_version).to eq(appcast_data[:short_version])
- expect(item_from_appcast_xml.version).to eq(appcast_data[:version])
+ it "returns an array of Items when given XML data" do
+ expect(items_from_appcast_xml).to eq(items[:appcast])
+ expect(first_item.title).to eq(item_hash[0][:title])
+ expect(first_item.pub_date).to eq(Time.parse(item_hash[0][:pub_date]))
+ expect(first_item.url).to eq(item_hash[0][:url])
+ expect(first_item.short_version).to eq(item_hash[0][:short_version])
+ expect(first_item.version).to eq(item_hash[0][:version])
+
+ expect(sparkle.items_from_content(xml[:no_versions_item])).to eq(items[:no_versions_item])
end
end
describe "::versions_from_content" do
+ let(:subbed_items) { items[:appcast].map { |item| item.nice_version.sub("1", "0") } }
+
it "returns an array of version strings when given content" do
- expect(sparkle.versions_from_content(appcast_xml)).to eq(versions)
+ expect(sparkle.versions_from_content(xml[:appcast])).to eq(versions)
+ expect(sparkle.versions_from_content(xml[:appcast_with_omitted_items])).to eq(versions)
+ expect(sparkle.versions_from_content(xml[:no_versions_item])).to eq([])
+ expect(sparkle.versions_from_content(xml[:undefined_namespace])).to eq(versions)
+ end
+
+ it "returns an empty array if no items are found" do
+ expect(sparkle.versions_from_content(xml[:no_items])).to eq([])
end
it "returns an array of version strings when given content and a block" do
# Returning a string from block
expect(
- sparkle.versions_from_content(appcast_xml) do |item|
- item.bundle_version&.nice_version&.sub("3", "4")
+ sparkle.versions_from_content(xml[:appcast]) do |item|
+ item.nice_version&.sub("1", "0")
end,
- ).to eq([item.bundle_version.nice_version.sub("3", "4")])
+ ).to eq([subbed_items[0]])
- # Returning an array of strings from block (unlikely to be used)
- expect(sparkle.versions_from_content(appcast_xml) { versions }).to eq(versions)
+ # Returning an array of strings from block
+ expect(
+ sparkle.versions_from_content(xml[:appcast]) do |items|
+ items.map { |item| item.nice_version&.sub("1", "0") }
+ end,
+ ).to eq(subbed_items)
end
it "returns an array of version strings when given content, a regex, and a block" do
- # Returning a string from block
+ # Returning a string from the block
expect(
- sparkle.versions_from_content(appcast_xml, title_regex) do |item, regex|
+ sparkle.versions_from_content(xml[:appcast], title_regex) do |item, regex|
item.title[regex, 1]
end,
- ).to eq([item.bundle_version.short_version])
+ ).to eq([items[:appcast][0].short_version])
- # Returning an array of strings from block (unlikely to be used)
expect(
- sparkle.versions_from_content(appcast_xml, title_regex) do |item, regex|
+ sparkle.versions_from_content(xml[:appcast], title_regex) do |items, regex|
+ next if (item = items[0]).blank?
+
+ match = item&.title&.match(regex)
+ next if match.blank?
+
+ "#{match[1]},#{item.version}"
+ end,
+ ).to eq(["#{items[:appcast][0].short_version},#{items[:appcast][0].version}"])
+
+ # Returning an array of strings from the block
+ expect(
+ sparkle.versions_from_content(xml[:appcast], title_regex) do |item, regex|
[item.title[regex, 1]]
end,
- ).to eq([item.bundle_version.short_version])
+ ).to eq([items[:appcast][0].short_version])
+
+ expect(
+ sparkle.versions_from_content(xml[:appcast], &:short_version),
+ ).to eq([items[:appcast][0].short_version])
+
+ expect(
+ sparkle.versions_from_content(xml[:appcast], title_regex) do |items, regex|
+ items.map { |item| item.title[regex, 1] }
+ end,
+ ).to eq(items[:appcast].map(&:short_version))
end
it "allows a nil return from a block" do
- expect(sparkle.versions_from_content(appcast_xml) { next }).to eq([])
+ expect(
+ sparkle.versions_from_content(xml[:appcast]) do |item|
+ _ = item # To appease `brew style` without modifying arg name
+ next
+ end,
+ ).to eq([])
end
it "errors on an invalid return type from a block" do
- expect { sparkle.versions_from_content(appcast_xml) { 123 } }
- .to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+ expect {
+ sparkle.versions_from_content(xml[:appcast]) do |item|
+ _ = item # To appease `brew style` without modifying arg name
+ 123
+ end
+ }.to raise_error(TypeError, Homebrew::Livecheck::Strategy::INVALID_BLOCK_RETURN_VALUE_MSG)
+ end
+
+ it "errors if the first block argument uses an unhandled name" do
+ expect { sparkle.versions_from_content(xml[:appcast]) { |something| something } }
+ .to raise_error("First argument of Sparkle `strategy` block must be `item` or `items`")
end
end
end | true |
Other | Homebrew | brew | 62eecace39149a07152fbff841ee3bf1fe58bfd8.json | Update RBI files for regexp_parser. | Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.5.0.rbi | @@ -94,6 +94,7 @@ end
class Regexp::Expression::Base
include ::Regexp::Expression::Shared
include ::RuboCop::Ext::RegexpParser::Expression::Base
+ extend ::Regexp::Expression::Shared::ClassMethods
def initialize(token, options = T.unsafe(nil)); end
@@ -387,6 +388,7 @@ end
class Regexp::Expression::Quantifier
include ::Regexp::Expression::Shared
+ extend ::Regexp::Expression::Shared::ClassMethods
def initialize(*args); end
@@ -431,7 +433,6 @@ Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
class << self
def build(options = T.unsafe(nil)); end
- def build_token; end
end
end
@@ -441,8 +442,7 @@ class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
def ts; end
class << self
- def add_to(subexpression, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
- def at_levels(level, set_level, conditional_level); end
+ def add_to(exp, params = T.unsafe(nil), active_opts = T.unsafe(nil)); end
end
end
@@ -458,6 +458,8 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio
end
module Regexp::Expression::Shared
+ mixes_in_class_methods ::Regexp::Expression::Shared::ClassMethods
+
def ==(other); end
def ===(other); end
def base_length; end
@@ -475,6 +477,7 @@ module Regexp::Expression::Shared
def terminal?; end
def to_s(format = T.unsafe(nil)); end
def to_str(format = T.unsafe(nil)); end
+ def token_class; end
def type?(test_type); end
private
@@ -487,6 +490,12 @@ module Regexp::Expression::Shared
end
end
+module Regexp::Expression::Shared::ClassMethods
+ def construct(params = T.unsafe(nil)); end
+ def construct_defaults; end
+ def token_class; end
+end
+
class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
include ::Enumerable
| false |
Other | Homebrew | brew | fa29537ca248d78a567c0a1afc670554e5bbcf91.json | Update RBI files for msgpack. | Library/Homebrew/sorbet/rbi/gems/msgpack@1.5.2.rbi | @@ -1,4 +1,4 @@
-# typed: true
+# typed: false
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `msgpack` gem.
@@ -58,15 +58,15 @@ end
module MessagePack
private
- def dump(v, *rest); end
+ def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
def load(src, param = T.unsafe(nil)); end
- def pack(v, *rest); end
+ def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
def unpack(src, param = T.unsafe(nil)); end
class << self
- def dump(v, *rest); end
+ def dump(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
def load(src, param = T.unsafe(nil)); end
- def pack(v, *rest); end
+ def pack(v, io = T.unsafe(nil), options = T.unsafe(nil)); end
def unpack(src, param = T.unsafe(nil)); end
end
end
@@ -75,8 +75,6 @@ module MessagePack::CoreExt
def to_msgpack(packer_or_io = T.unsafe(nil)); end
end
-MessagePack::DEFAULT_EMPTY_PARAMS = T.let(T.unsafe(nil), Hash)
-
class MessagePack::ExtensionValue < ::Struct
include ::MessagePack::CoreExt
@@ -92,11 +90,38 @@ class MessagePack::Factory
def dump(v, *rest); end
def load(src, param = T.unsafe(nil)); end
def pack(v, *rest); end
+ def pool(size = T.unsafe(nil), **options); end
def registered_types(selector = T.unsafe(nil)); end
def type_registered?(klass_or_type, selector = T.unsafe(nil)); end
def unpack(src, param = T.unsafe(nil)); end
end
+class MessagePack::Factory::Pool
+ def initialize(factory, size, options = T.unsafe(nil)); end
+
+ def dump(object); end
+ def load(data); end
+end
+
+class MessagePack::Factory::Pool::AbstractPool
+ def initialize(size, &block); end
+
+ def checkin(member); end
+ def checkout; end
+end
+
+class MessagePack::Factory::Pool::PackerPool < ::MessagePack::Factory::Pool::AbstractPool
+ private
+
+ def reset(packer); end
+end
+
+class MessagePack::Factory::Pool::UnpackerPool < ::MessagePack::Factory::Pool::AbstractPool
+ private
+
+ def reset(unpacker); end
+end
+
class MessagePack::Packer
def registered_types; end
def type_registered?(klass_or_type); end | false |
Other | Homebrew | brew | addb485c748876f6d10f478357fa09558a8b7899.json | Update RBI files for rack. | Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.1.rbi | @@ -660,8 +660,7 @@ end
Rack::Multipart::ATTRIBUTE = T.let(T.unsafe(nil), Regexp)
Rack::Multipart::ATTRIBUTE_CHAR = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::BROKEN_QUOTED = T.let(T.unsafe(nil), Regexp)
-Rack::Multipart::BROKEN_UNQUOTED = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::BROKEN = T.let(T.unsafe(nil), Regexp)
Rack::Multipart::CONDISP = T.let(T.unsafe(nil), Regexp)
Rack::Multipart::DISPPARM = T.let(T.unsafe(nil), Regexp)
Rack::Multipart::EOL = T.let(T.unsafe(nil), String) | false |
Other | Homebrew | brew | 1f43bf32a4b1724d4cbedb81188f84eea93da491.json | cask: add statement when upgrade won't be installed | Library/Homebrew/cask/cmd/upgrade.rb | @@ -102,7 +102,15 @@ def self.upgrade_casks(
casks.select do |cask|
raise CaskNotInstalledError, cask if !cask.installed? && !force
- cask.outdated?(greedy: true)
+ if cask.outdated?(greedy: true)
+ true
+ elsif cask.version.latest?
+ opoo "Not upgrading #{cask.token}, the downloaded artifact has not changed"
+ false
+ else
+ opoo "Not upgrading #{cask.token}, the latest version is already installed"
+ false
+ end
end
end
| false |
Other | Homebrew | brew | 403a4d4a494643d0ecfd91f92812a6f5bfa9a9ff.json | Curl: Check all responses for protected cookies
The response from a URL protected by Cloudflare may only provide a
relevant cookie on the first response but
`#curl_http_content_headers_and_checksum` only returns the headers of
the final response. In this scenario, `#curl_check_http_content` isn't
able to properly detect the protected URL and this is surfaced as an
error instead of skipping the URL.
This resolves the issue by including the array of response hashes in
the return value from `#curl_http_content_headers_and_checksum`, so
we can check all the responses in `#curl_check_http_content`. | Library/Homebrew/utils/curl.rb | @@ -198,21 +198,20 @@ def curl_output(*args, **options)
end
# Check if a URL is protected by CloudFlare (e.g. badlion.net and jaxx.io).
- # @param details [Hash] Response information from
- # `#curl_http_content_headers_and_checksum`.
+ # @param response [Hash] A response hash from `#parse_curl_response`.
# @return [true, false] Whether a response contains headers indicating that
# the URL is protected by Cloudflare.
- sig { params(details: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
- def url_protected_by_cloudflare?(details)
- return false if details[:headers].blank?
- return false unless [403, 503].include?(details[:status_code].to_i)
+ sig { params(response: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+ def url_protected_by_cloudflare?(response)
+ return false if response[:headers].blank?
+ return false unless [403, 503].include?(response[:status_code].to_i)
- set_cookie_header = Array(details[:headers]["set-cookie"])
+ set_cookie_header = Array(response[:headers]["set-cookie"])
has_cloudflare_cookie_header = set_cookie_header.compact.any? do |cookie|
cookie.match?(/^(__cfduid|__cf_bm)=/i)
end
- server_header = Array(details[:headers]["server"])
+ server_header = Array(response[:headers]["server"])
has_cloudflare_server = server_header.compact.any? do |server|
server.match?(/^cloudflare/i)
end
@@ -221,16 +220,15 @@ def url_protected_by_cloudflare?(details)
end
# Check if a URL is protected by Incapsula (e.g. corsair.com).
- # @param details [Hash] Response information from
- # `#curl_http_content_headers_and_checksum`.
+ # @param response [Hash] A response hash from `#parse_curl_response`.
# @return [true, false] Whether a response contains headers indicating that
# the URL is protected by Incapsula.
- sig { params(details: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
- def url_protected_by_incapsula?(details)
- return false if details[:headers].blank?
- return false if details[:status_code].to_i != 403
+ sig { params(response: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+ def url_protected_by_incapsula?(response)
+ return false if response[:headers].blank?
+ return false if response[:status_code].to_i != 403
- set_cookie_header = Array(details[:headers]["set-cookie"])
+ set_cookie_header = Array(response[:headers]["set-cookie"])
set_cookie_header.compact.any? { |cookie| cookie.match?(/^(visid_incap|incap_ses)_/i) }
end
@@ -284,7 +282,9 @@ def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default],
end
unless http_status_ok?(details[:status_code])
- return if url_protected_by_cloudflare?(details) || url_protected_by_incapsula?(details)
+ return if details[:responses].any? do |response|
+ url_protected_by_cloudflare?(response) || url_protected_by_incapsula?(response)
+ end
return "The #{url_type} #{url} is not reachable (HTTP status code #{details[:status_code]})"
end
@@ -403,6 +403,7 @@ def curl_http_content_headers_and_checksum(
content_length: content_length,
file: file_contents,
file_hash: file_hash,
+ responses: responses,
}
ensure
file.unlink | false |
Other | Homebrew | brew | deec796294eb165203bcbae07cd8d7e0fa7cadcb.json | Update RBI files for rubocop-performance. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -4618,6 +4618,18 @@ class RuboCop::Cop::FormulaCop
def required_dependency_name?(param0, param1); end
end
+class RuboCop::Cop::Performance::DeletePrefix
+ extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Performance::DeleteSuffix
+ extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Performance::RedundantEqualityComparisonBlock
+ extend ::RuboCop::Cop::TargetRubyVersion
+end
+
class RuboCop::Cop::RSpec::ChangeByZero
def expect_change_with_arguments(param0=T.unsafe(nil)); end
| false |
Other | Homebrew | brew | cf3742fd472eae83856fd09bdc82967684d4ba5a.json | sorbet: Update RBI files.
Autogenerated by the [sorbet](https://github.com/Homebrew/brew/blob/master/.github/workflows/sorbet.yml) workflow. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -2572,7 +2572,9 @@ module Homebrew::EnvConfig
def self.temp(); end
- def self.update_report_only_installed?(); end
+ def self.update_report_all_formulae?(); end
+
+ def self.update_report_version_changed_formulae?(); end
def self.update_to_tag?(); end
| false |
Other | Homebrew | brew | 580fb58f6264153f804d681f92be6073a6683014.json | utils/github: take last artifact rather than first | Library/Homebrew/utils/github.rb | @@ -353,7 +353,7 @@ def get_artifact_url(workflow_array)
EOS
end
- artifact.first["archive_download_url"]
+ artifact.last["archive_download_url"]
end
def public_member_usernames(org, per_page: 100) | false |
Other | Homebrew | brew | 5e6d5f68cacc5e0dbcd130ca62b811edd66bfe96.json | test/download_strategies/curl_github_packages: fix bad const override | Library/Homebrew/test/download_strategies/curl_github_packages_spec.rb | @@ -10,9 +10,11 @@
let(:url) { "https://#{GitHubPackages::URL_DOMAIN}/v2/homebrew/core/spec_test/manifests/1.2.3" }
let(:version) { "1.2.3" }
let(:specs) { {} }
+ let(:authorization) { nil }
describe "#fetch" do
before do
+ stub_const("HOMEBREW_GITHUB_PACKAGES_AUTH", authorization) if authorization.present?
strategy.temporary_path.dirname.mkpath
FileUtils.touch strategy.temporary_path
end
@@ -31,10 +33,6 @@
context "with Github Packages authentication defined" do
let(:authorization) { "Bearer dead-beef-cafe" }
- before do
- HOMEBREW_GITHUB_PACKAGES_AUTH = authorization.freeze
- end
-
it "calls curl with the provided header value" do
expect(strategy).to receive(:system_command).with(
/curl/, | false |
Other | Homebrew | brew | ac2f52cef33bd374c945e51e9242859f0849bd73.json | cask: fix greedy outdated command | Library/Homebrew/cask/cask.rb | @@ -166,13 +166,11 @@ def outdated_versions(greedy: false, greedy_latest: false, greedy_auto_updates:
version
end
- if greedy || greedy_latest || (greedy_auto_updates && auto_updates)
- if latest_version.latest?
- return versions if outdated_download_sha?
+ if latest_version.latest?
+ return versions if (greedy || greedy_latest) && outdated_download_sha?
- return []
- end
- elsif auto_updates
+ return []
+ elsif auto_updates && !(greedy || greedy_auto_updates)
return []
end
| false |
Other | Homebrew | brew | b2796ec7fb9641becb8f8486b3695668447e2ee3.json | docs: clarify application of HOMEBREW_ARTIFACT_DOMAIN
bottle URLs are treated differently than any other URL.
this change clarifies the resulting URLs in the manpage.
closes #13222 | Library/Homebrew/env_config.rb | @@ -23,7 +23,12 @@ module EnvConfig
description: "Prefix all download URLs, including those for bottles, with this value. " \
"For example, `HOMEBREW_ARTIFACT_DOMAIN=http://localhost:8080` will cause a " \
"formula with the URL `https://example.com/foo.tar.gz` to instead download from " \
- "`http://localhost:8080/example.com/foo.tar.gz`.",
+ "`http://localhost:8080/https://example.com/foo.tar.gz`. " \
+ "Bottle URLs however, have their domain replaced with this prefix. " \
+ "Using the same value for example, would cause data hosted under " \
+ "`https://ghcr.io/v2/homebrew/core/gettext/manifests/0.21` " \
+ "to be instead downloaded from " \
+ "`http://localhost:8080/v2/homebrew/core/gettext/manifests/0.21`",
},
HOMEBREW_AUTO_UPDATE_SECS: {
description: "Run `brew update` once every `HOMEBREW_AUTO_UPDATE_SECS` seconds before some commands, " \ | true |
Other | Homebrew | brew | b2796ec7fb9641becb8f8486b3695668447e2ee3.json | docs: clarify application of HOMEBREW_ARTIFACT_DOMAIN
bottle URLs are treated differently than any other URL.
this change clarifies the resulting URLs in the manpage.
closes #13222 | Library/Homebrew/test/download_strategies/curl_spec.rb | @@ -10,13 +10,16 @@
let(:url) { "https://example.com/foo.tar.gz" }
let(:version) { "1.2.3" }
let(:specs) { { user: "download:123456" } }
+ let(:artifact_domain) { nil }
it "parses the opts and sets the corresponding args" do
expect(strategy.send(:_curl_args)).to eq(["--user", "download:123456"])
end
describe "#fetch" do
before do
+ allow(Homebrew::EnvConfig).to receive(:artifact_domain).and_return(artifact_domain)
+
strategy.temporary_path.dirname.mkpath
FileUtils.touch strategy.temporary_path
end
@@ -123,6 +126,59 @@
strategy.fetch
end
end
+
+ context "with artifact_domain set" do
+ let(:artifact_domain) { "https://mirror.example.com/oci" }
+
+ context "with an asset hosted under example.com" do
+ let(:status) { instance_double(Process::Status, success?: true, exitstatus: 0) }
+
+ it "prefixes the URL unchanged" do
+ expect(strategy).to receive(:system_command).with(
+ /curl/,
+ hash_including(args: array_including_cons("#{artifact_domain}/#{url}")),
+ )
+ .at_least(:once)
+ .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
+
+ strategy.fetch
+ end
+ end
+
+ context "with an asset hosted under #{GitHubPackages::URL_DOMAIN} (HTTP)" do
+ let(:resource_path) { "v2/homebrew/core/spec/manifests/0.0" }
+ let(:url) { "http://#{GitHubPackages::URL_DOMAIN}/#{resource_path}" }
+ let(:status) { instance_double(Process::Status, success?: true, exitstatus: 0) }
+
+ it "rewrites the URL correctly" do
+ expect(strategy).to receive(:system_command).with(
+ /curl/,
+ hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
+ )
+ .at_least(:once)
+ .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
+
+ strategy.fetch
+ end
+ end
+
+ context "with an asset hosted under #{GitHubPackages::URL_DOMAIN} (HTTPS)" do
+ let(:resource_path) { "v2/homebrew/core/spec/manifests/0.0" }
+ let(:url) { "https://#{GitHubPackages::URL_DOMAIN}/#{resource_path}" }
+ let(:status) { instance_double(Process::Status, success?: true, exitstatus: 0) }
+
+ it "rewrites the URL correctly" do
+ expect(strategy).to receive(:system_command).with(
+ /curl/,
+ hash_including(args: array_including_cons("#{artifact_domain}/#{resource_path}")),
+ )
+ .at_least(:once)
+ .and_return(SystemCommand::Result.new(["curl"], [""], status, secrets: []))
+
+ strategy.fetch
+ end
+ end
+ end
end
describe "#cached_location" do | true |
Other | Homebrew | brew | 38ae98cbcd2690142506aa86b34a769175e53c41.json | livecheck: improve host checks to instead check domains | Library/Homebrew/livecheck/livecheck.rb | @@ -492,34 +492,35 @@ def checkable_urls(formula_or_cask)
sig { params(url: String).returns(String) }
def preprocess_url(url)
begin
- uri = URI.parse url
- rescue URI::InvalidURIError
+ uri = Addressable::URI.parse url
+ rescue Addressable::URI::InvalidURIError
return url
end
host = uri.host
+ domain = uri.domain
path = uri.path
return url if host.nil? || path.nil?
- host = "github.com" if host == "github.s3.amazonaws.com"
+ domain = host = "github.com" if host == "github.s3.amazonaws.com"
path = path.delete_prefix("/").delete_suffix(".git")
scheme = uri.scheme
- if host.end_with?("github.com")
+ if domain == "github.com"
return url if path.match? %r{/releases/latest/?$}
owner, repo = path.delete_prefix("downloads/").split("/")
url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
- elsif host.end_with?(*GITEA_INSTANCES)
+ elsif GITEA_INSTANCES.include?(domain)
return url if path.match? %r{/releases/latest/?$}
owner, repo = path.split("/")
url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
- elsif host.end_with?(*GOGS_INSTANCES)
+ elsif GOGS_INSTANCES.include?(domain)
owner, repo = path.split("/")
url = "#{scheme}://#{host}/#{owner}/#{repo}.git"
# sourcehut
- elsif host.end_with?("git.sr.ht")
+ elsif host == "git.sr.ht"
owner, repo = path.split("/")
url = "#{scheme}://#{host}/#{owner}/#{repo}"
# GitLab (gitlab.com or self-hosted) | false |
Other | Homebrew | brew | d47517f635001088fb1fb7bf43231b1fd5168d3b.json | exceptions: handle backslash in args for BuildError | Library/Homebrew/exceptions.rb | @@ -479,7 +479,7 @@ def initialize(formula, cmd, args, env)
@cmd = cmd
@args = args
@env = env
- pretty_args = Array(args).map { |arg| arg.to_s.gsub " ", "\\ " }.join(" ")
+ pretty_args = Array(args).map { |arg| arg.to_s.gsub(/[\\ ]/, "\\\\\\0") }.join(" ")
super "Failed executing: #{cmd} #{pretty_args}".strip
end
| false |
Other | Homebrew | brew | 2f0a53c0daf1ee1f3039ab32213916d22ff7e277.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/livecheck/livecheck.rb | @@ -5,6 +5,7 @@
require "livecheck/livecheck_version"
require "livecheck/skip_conditions"
require "livecheck/strategy"
+require "addressable"
require "ruby-progressbar"
require "uri"
@@ -529,26 +530,33 @@ def preprocess_url(url)
url
end
- # Fetch with brewed curl if using the download or homepage URL
- # and the download URL specifies `using: :homebrew_curl`.
+ # livecheck should fetch a URL using brewed curl if the formula/cask
+ # contains a `stable`/`url` or `head` URL `using: :homebrew_curl` that
+ # shares the same root domain.
sig { params(formula_or_cask: T.any(Formula, Cask::Cask), url: String).returns(T::Boolean) }
def use_homebrew_curl?(formula_or_cask, url)
- if checkable_urls(formula_or_cask).include?(url)
- case formula_or_cask
- when Formula
- [:stable, :head].any? do |spec_name|
- next false unless (spec = formula_or_cask.send(spec_name))
+ url_root_domain = Addressable::URI.parse(url)&.domain
+ return false if url_root_domain.blank?
- spec.using == :homebrew_curl
- end
- when Cask::Cask
- formula_or_cask.url.using == :homebrew_curl
- else
- T.absurd(formula_or_cask)
+ # Collect root domains of URLs with `using: :homebrew_curl`
+ homebrew_curl_root_domains = []
+ case formula_or_cask
+ when Formula
+ [:stable, :head].each do |spec_name|
+ next unless (spec = formula_or_cask.send(spec_name))
+ next unless spec.using == :homebrew_curl
+
+ domain = Addressable::URI.parse(spec.url)&.domain
+ homebrew_curl_root_domains << domain if domain.present?
end
- else
- false
+ when Cask::Cask
+ return false unless formula_or_cask.url.using == :homebrew_curl
+
+ domain = Addressable::URI.parse(formula_or_cask.url.to_s)&.domain
+ homebrew_curl_root_domains << domain if domain.present?
end
+
+ homebrew_curl_root_domains.include?(url_root_domain)
end
# Identifies the latest version of the formula and returns a Hash containing
@@ -662,6 +670,7 @@ def latest_version(
when "PageMatch", "HeaderMatch"
use_homebrew_curl?((referenced_formula_or_cask || formula_or_cask), url)
end
+ puts "Homebrew curl?: Yes" if debug && homebrew_curl.present?
strategy_data = strategy.find_versions(
url: url,
@@ -743,6 +752,7 @@ def latest_version(
version_info[:meta][:url][:strategy] = strategy_data[:url]
end
version_info[:meta][:url][:final] = strategy_data[:final_url] if strategy_data[:final_url]
+ version_info[:meta][:url][:homebrew_curl] = homebrew_curl if homebrew_curl.present?
version_info[:meta][:strategy] = strategy.present? ? strategy_name : nil
version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names[s] } if strategies.present? | true |
Other | Homebrew | brew | 2f0a53c0daf1ee1f3039ab32213916d22ff7e277.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/test/livecheck/livecheck_spec.rb | @@ -16,7 +16,7 @@
formula("test") do
desc "Test formula"
homepage "https://brew.sh"
- url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
+ url "https://brew.sh/test-0.0.1.tgz"
head "https://github.com/Homebrew/brew.git"
livecheck do
@@ -31,7 +31,7 @@
cask "test" do
version "0.0.1,2"
- url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
+ url "https://brew.sh/test-0.0.1.dmg"
name "Test"
desc "Test cask"
homepage "https://brew.sh"
@@ -158,13 +158,67 @@
end
describe "::use_homebrew_curl?" do
- it "uses brewed curl if called for by the download URL" do
+ let(:example_url) { "https://www.example.com/test-0.0.1.tgz" }
+
+ let(:f_homebrew_curl) do
+ formula("test") do
+ desc "Test formula"
+ homepage "https://brew.sh"
+ url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
+ # head is deliberably omitted to exercise more of the method
+
+ livecheck do
+ url "https://formulae.brew.sh/api/formula/ruby.json"
+ regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+ end
+ end
+ end
+
+ let(:c_homebrew_curl) do
+ Cask::CaskLoader.load(+<<-RUBY)
+ cask "test" do
+ version "0.0.1,2"
+
+ url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
+ name "Test"
+ desc "Test cask"
+ homepage "https://brew.sh"
+
+ livecheck do
+ url "https://formulae.brew.sh/api/formula/ruby.json"
+ regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+ end
+ end
+ RUBY
+ end
+
+ it "returns `true` when URL matches a `using: :homebrew_curl` URL" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, livecheck_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, stable_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, livecheck_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, cask_url)).to be(true)
+ end
+
+ it "returns `false` if URL root domain differs from `using: :homebrew_curl` URLs" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, example_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, example_url)).to be(false)
+ end
+
+ it "returns `false` if a `using: homebrew_curl` URL is not present" do
expect(livecheck.use_homebrew_curl?(f, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(f, example_url)).to be(false)
expect(livecheck.use_homebrew_curl?(c, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c, example_url)).to be(false)
+ end
+
+ it "returns `false` if URL string does not contain a domain" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, "test")).to be(false)
end
end
| true |
Other | Homebrew | brew | 95213893a614fa399d16efd13c9440bb0dc5e8d5.json | Revert "Livecheck: Use Homebrew curl based on root domain" | Library/Homebrew/Gemfile | @@ -6,7 +6,6 @@ source "https://rubygems.org"
# * nokogiri - use rexml instead for XML parsing
# installed gems (should all be require: false)
-gem "addressable", require: false
gem "bootsnap", require: false
gem "byebug", require: false
gem "json_schemer", require: false | true |
Other | Homebrew | brew | 95213893a614fa399d16efd13c9440bb0dc5e8d5.json | Revert "Livecheck: Use Homebrew curl based on root domain" | Library/Homebrew/Gemfile.lock | @@ -204,7 +204,6 @@ PLATFORMS
DEPENDENCIES
activesupport (< 7)
- addressable
bootsnap
byebug
concurrent-ruby | true |
Other | Homebrew | brew | 95213893a614fa399d16efd13c9440bb0dc5e8d5.json | Revert "Livecheck: Use Homebrew curl based on root domain" | Library/Homebrew/livecheck/livecheck.rb | @@ -5,7 +5,6 @@
require "livecheck/livecheck_version"
require "livecheck/skip_conditions"
require "livecheck/strategy"
-require "addressable"
require "ruby-progressbar"
require "uri"
@@ -530,33 +529,26 @@ def preprocess_url(url)
url
end
- # livecheck should fetch a URL using brewed curl if the formula/cask
- # contains a `stable`/`url` or `head` URL `using: :homebrew_curl` that
- # shares the same root domain.
+ # Fetch with brewed curl if using the download or homepage URL
+ # and the download URL specifies `using: :homebrew_curl`.
sig { params(formula_or_cask: T.any(Formula, Cask::Cask), url: String).returns(T::Boolean) }
def use_homebrew_curl?(formula_or_cask, url)
- url_root_domain = Addressable::URI.parse(url)&.domain
- return false if url_root_domain.blank?
+ if checkable_urls(formula_or_cask).include?(url)
+ case formula_or_cask
+ when Formula
+ [:stable, :head].any? do |spec_name|
+ next false unless (spec = formula_or_cask.send(spec_name))
- # Collect root domains of URLs with `using: :homebrew_curl`
- homebrew_curl_root_domains = []
- case formula_or_cask
- when Formula
- [:stable, :head].each do |spec_name|
- next unless (spec = formula_or_cask.send(spec_name))
- next unless spec.using == :homebrew_curl
-
- domain = Addressable::URI.parse(spec.url)&.domain
- homebrew_curl_root_domains << domain if domain.present?
+ spec.using == :homebrew_curl
+ end
+ when Cask::Cask
+ formula_or_cask.url.using == :homebrew_curl
+ else
+ T.absurd(formula_or_cask)
end
- when Cask::Cask
- return false unless formula_or_cask.url.using == :homebrew_curl
-
- domain = Addressable::URI.parse(formula_or_cask.url.to_s)&.domain
- homebrew_curl_root_domains << domain if domain.present?
+ else
+ false
end
-
- homebrew_curl_root_domains.include?(url_root_domain)
end
# Identifies the latest version of the formula and returns a Hash containing
@@ -670,7 +662,6 @@ def latest_version(
when "PageMatch", "HeaderMatch"
use_homebrew_curl?((referenced_formula_or_cask || formula_or_cask), url)
end
- puts "Homebrew curl?: Yes" if debug && homebrew_curl.present?
strategy_data = strategy.find_versions(
url: url,
@@ -752,7 +743,6 @@ def latest_version(
version_info[:meta][:url][:strategy] = strategy_data[:url]
end
version_info[:meta][:url][:final] = strategy_data[:final_url] if strategy_data[:final_url]
- version_info[:meta][:url][:homebrew_curl] = homebrew_curl if homebrew_curl.present?
version_info[:meta][:strategy] = strategy.present? ? strategy_name : nil
version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names[s] } if strategies.present? | true |
Other | Homebrew | brew | 95213893a614fa399d16efd13c9440bb0dc5e8d5.json | Revert "Livecheck: Use Homebrew curl based on root domain" | Library/Homebrew/test/livecheck/livecheck_spec.rb | @@ -16,7 +16,7 @@
formula("test") do
desc "Test formula"
homepage "https://brew.sh"
- url "https://brew.sh/test-0.0.1.tgz"
+ url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
head "https://github.com/Homebrew/brew.git"
livecheck do
@@ -31,7 +31,7 @@
cask "test" do
version "0.0.1,2"
- url "https://brew.sh/test-0.0.1.dmg"
+ url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
name "Test"
desc "Test cask"
homepage "https://brew.sh"
@@ -158,67 +158,13 @@
end
describe "::use_homebrew_curl?" do
- let(:example_url) { "https://www.example.com/test-0.0.1.tgz" }
-
- let(:f_homebrew_curl) do
- formula("test") do
- desc "Test formula"
- homepage "https://brew.sh"
- url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
- # head is deliberably omitted to exercise more of the method
-
- livecheck do
- url "https://formulae.brew.sh/api/formula/ruby.json"
- regex(/"stable":"(\d+(?:\.\d+)+)"/i)
- end
- end
- end
-
- let(:c_homebrew_curl) do
- Cask::CaskLoader.load(+<<-RUBY)
- cask "test" do
- version "0.0.1,2"
-
- url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
- name "Test"
- desc "Test cask"
- homepage "https://brew.sh"
-
- livecheck do
- url "https://formulae.brew.sh/api/formula/ruby.json"
- regex(/"stable":"(\d+(?:\.\d+)+)"/i)
- end
- end
- RUBY
- end
-
- it "returns `true` when URL matches a `using: :homebrew_curl` URL" do
- expect(livecheck.use_homebrew_curl?(f_homebrew_curl, livecheck_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(f_homebrew_curl, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(f_homebrew_curl, stable_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(c_homebrew_curl, livecheck_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(c_homebrew_curl, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(c_homebrew_curl, cask_url)).to be(true)
- end
-
- it "returns `false` if URL root domain differs from `using: :homebrew_curl` URLs" do
- expect(livecheck.use_homebrew_curl?(f_homebrew_curl, example_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c_homebrew_curl, example_url)).to be(false)
- end
-
- it "returns `false` if a `using: homebrew_curl` URL is not present" do
+ it "uses brewed curl if called for by the download URL" do
expect(livecheck.use_homebrew_curl?(f, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(f, example_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(true)
expect(livecheck.use_homebrew_curl?(c, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c, example_url)).to be(false)
- end
-
- it "returns `false` if URL string does not contain a domain" do
- expect(livecheck.use_homebrew_curl?(f_homebrew_curl, "test")).to be(false)
+ expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(true)
end
end
| true |
Other | Homebrew | brew | 41d2e21f8e83234dde673a9f39e3f8103f38360c.json | Update RBI files for rubocop-rspec. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -4616,6 +4616,21 @@ class RuboCop::Cop::FormulaCop
def required_dependency_name?(param0, param1); end
end
+class RuboCop::Cop::RSpec::ChangeByZero
+ def expect_change_with_arguments(param0=T.unsafe(nil)); end
+
+ def expect_change_with_block(param0=T.unsafe(nil)); end
+
+ def on_send(node); end
+ MSG = ::T.let(nil, ::T.untyped)
+ MSG_COMPOUND = ::T.let(nil, ::T.untyped)
+ RESTRICT_ON_SEND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::RSpec::ChangeByZero
+ extend ::RuboCop::Cop::AutoCorrector
+end
+
module RuboCop::RSpec::ExpectOffense
def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
| false |
Other | Homebrew | brew | 1c20be6c85d46d8a729f0d8ac13f5769a083e104.json | Update RBI files for sorbet-static-and-runtime. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -3591,8 +3591,6 @@ class Object
PATCH_B_SHA256 = ::T.let(nil, ::T.untyped)
REQUIRED_RUBY_X = ::T.let(nil, ::T.untyped)
REQUIRED_RUBY_Y = ::T.let(nil, ::T.untyped)
- RUBY18 = ::T.let(nil, ::T.untyped)
- RUBY19 = ::T.let(nil, ::T.untyped)
RUBY_BIN = ::T.let(nil, ::T.untyped)
RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
@@ -4360,536 +4358,6 @@ class ResourceStageContext
extend ::T::Private::Methods::SingletonMethodHooks
end
-class Ripper
- def column(); end
-
- def encoding(); end
-
- def end_seen?(); end
-
- def error?(); end
-
- def filename(); end
-
- def initialize(*arg); end
-
- def lineno(); end
-
- def parse(); end
-
- def state(); end
-
- def yydebug(); end
-
- def yydebug=(yydebug); end
- EXPR_ARG = ::T.let(nil, ::T.untyped)
- EXPR_ARG_ANY = ::T.let(nil, ::T.untyped)
- EXPR_BEG = ::T.let(nil, ::T.untyped)
- EXPR_BEG_ANY = ::T.let(nil, ::T.untyped)
- EXPR_CLASS = ::T.let(nil, ::T.untyped)
- EXPR_CMDARG = ::T.let(nil, ::T.untyped)
- EXPR_DOT = ::T.let(nil, ::T.untyped)
- EXPR_END = ::T.let(nil, ::T.untyped)
- EXPR_ENDARG = ::T.let(nil, ::T.untyped)
- EXPR_ENDFN = ::T.let(nil, ::T.untyped)
- EXPR_END_ANY = ::T.let(nil, ::T.untyped)
- EXPR_FITEM = ::T.let(nil, ::T.untyped)
- EXPR_FNAME = ::T.let(nil, ::T.untyped)
- EXPR_LABEL = ::T.let(nil, ::T.untyped)
- EXPR_LABELED = ::T.let(nil, ::T.untyped)
- EXPR_MID = ::T.let(nil, ::T.untyped)
- EXPR_NONE = ::T.let(nil, ::T.untyped)
- EXPR_VALUE = ::T.let(nil, ::T.untyped)
- PARSER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
- SCANNER_EVENT_TABLE = ::T.let(nil, ::T.untyped)
- Version = ::T.let(nil, ::T.untyped)
-end
-
-class Ripper::Filter
- def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end
-end
-
-class Ripper::Lexer
- def lex(); end
-
- def tokenize(); end
-end
-
-class Ripper::Lexer::Elem
- def event(); end
-
- def event=(_); end
-
- def initialize(pos, event, tok, state); end
-
- def pos(); end
-
- def pos=(_); end
-
- def state(); end
-
- def state=(_); end
-
- def tok(); end
-
- def tok=(_); end
-end
-
-class Ripper::Lexer::Elem
- def self.[](*arg); end
-
- def self.members(); end
-end
-
-class Ripper::Lexer::State
- def &(i); end
-
- def ==(i); end
-
- def allbits?(i); end
-
- def anybits?(i); end
-
- def initialize(i); end
-
- def nobits?(i); end
-
- def to_i(); end
-
- def to_int(); end
-
- def to_int=(_); end
-
- def to_s=(_); end
-
- def |(i); end
-end
-
-class Ripper::Lexer::State
- def self.[](*arg); end
-
- def self.members(); end
-end
-
-class Ripper::Lexer
-end
-
-class Ripper::SexpBuilder
- def on_BEGIN(*args); end
-
- def on_CHAR(tok); end
-
- def on_END(*args); end
-
- def on___end__(tok); end
-
- def on_alias(*args); end
-
- def on_alias_error(*args); end
-
- def on_aref(*args); end
-
- def on_aref_field(*args); end
-
- def on_arg_ambiguous(*args); end
-
- def on_arg_paren(*args); end
-
- def on_args_add(*args); end
-
- def on_args_add_block(*args); end
-
- def on_args_add_star(*args); end
-
- def on_args_new(*args); end
-
- def on_array(*args); end
-
- def on_assign(*args); end
-
- def on_assign_error(*args); end
-
- def on_assoc_new(*args); end
-
- def on_assoc_splat(*args); end
-
- def on_assoclist_from_args(*args); end
-
- def on_backref(tok); end
-
- def on_backtick(tok); end
-
- def on_bare_assoc_hash(*args); end
-
- def on_begin(*args); end
-
- def on_binary(*args); end
-
- def on_block_var(*args); end
-
- def on_blockarg(*args); end
-
- def on_bodystmt(*args); end
-
- def on_brace_block(*args); end
-
- def on_break(*args); end
-
- def on_call(*args); end
-
- def on_case(*args); end
-
- def on_class(*args); end
-
- def on_class_name_error(*args); end
-
- def on_comma(tok); end
-
- def on_command(*args); end
-
- def on_command_call(*args); end
-
- def on_comment(tok); end
-
- def on_const(tok); end
-
- def on_const_path_field(*args); end
-
- def on_const_path_ref(*args); end
-
- def on_const_ref(*args); end
-
- def on_cvar(tok); end
-
- def on_def(*args); end
-
- def on_defined(*args); end
-
- def on_defs(*args); end
-
- def on_do_block(*args); end
-
- def on_dot2(*args); end
-
- def on_dot3(*args); end
-
- def on_dyna_symbol(*args); end
-
- def on_else(*args); end
-
- def on_elsif(*args); end
-
- def on_embdoc(tok); end
-
- def on_embdoc_beg(tok); end
-
- def on_embdoc_end(tok); end
-
- def on_embexpr_beg(tok); end
-
- def on_embexpr_end(tok); end
-
- def on_embvar(tok); end
-
- def on_ensure(*args); end
-
- def on_excessed_comma(*args); end
-
- def on_fcall(*args); end
-
- def on_field(*args); end
-
- def on_float(tok); end
-
- def on_for(*args); end
-
- def on_gvar(tok); end
-
- def on_hash(*args); end
-
- def on_heredoc_beg(tok); end
-
- def on_heredoc_end(tok); end
-
- def on_ident(tok); end
-
- def on_if(*args); end
-
- def on_if_mod(*args); end
-
- def on_ifop(*args); end
-
- def on_ignored_nl(tok); end
-
- def on_ignored_sp(tok); end
-
- def on_imaginary(tok); end
-
- def on_int(tok); end
-
- def on_ivar(tok); end
-
- def on_kw(tok); end
-
- def on_kwrest_param(*args); end
-
- def on_label(tok); end
-
- def on_label_end(tok); end
-
- def on_lambda(*args); end
-
- def on_lbrace(tok); end
-
- def on_lbracket(tok); end
-
- def on_lparen(tok); end
-
- def on_magic_comment(*args); end
-
- def on_massign(*args); end
-
- def on_method_add_arg(*args); end
-
- def on_method_add_block(*args); end
-
- def on_mlhs_add(*args); end
-
- def on_mlhs_add_post(*args); end
-
- def on_mlhs_add_star(*args); end
-
- def on_mlhs_new(*args); end
-
- def on_mlhs_paren(*args); end
-
- def on_module(*args); end
-
- def on_mrhs_add(*args); end
-
- def on_mrhs_add_star(*args); end
-
- def on_mrhs_new(*args); end
-
- def on_mrhs_new_from_args(*args); end
-
- def on_next(*args); end
-
- def on_nl(tok); end
-
- def on_op(tok); end
-
- def on_opassign(*args); end
-
- def on_operator_ambiguous(*args); end
-
- def on_param_error(*args); end
-
- def on_params(*args); end
-
- def on_paren(*args); end
-
- def on_parse_error(*args); end
-
- def on_period(tok); end
-
- def on_program(*args); end
-
- def on_qsymbols_add(*args); end
-
- def on_qsymbols_beg(tok); end
-
- def on_qsymbols_new(*args); end
-
- def on_qwords_add(*args); end
-
- def on_qwords_beg(tok); end
-
- def on_qwords_new(*args); end
-
- def on_rational(tok); end
-
- def on_rbrace(tok); end
-
- def on_rbracket(tok); end
-
- def on_redo(*args); end
-
- def on_regexp_add(*args); end
-
- def on_regexp_beg(tok); end
-
- def on_regexp_end(tok); end
-
- def on_regexp_literal(*args); end
-
- def on_regexp_new(*args); end
-
- def on_rescue(*args); end
-
- def on_rescue_mod(*args); end
-
- def on_rest_param(*args); end
-
- def on_retry(*args); end
-
- def on_return(*args); end
-
- def on_return0(*args); end
-
- def on_rparen(tok); end
-
- def on_sclass(*args); end
-
- def on_semicolon(tok); end
-
- def on_sp(tok); end
-
- def on_stmts_add(*args); end
-
- def on_stmts_new(*args); end
-
- def on_string_add(*args); end
-
- def on_string_concat(*args); end
-
- def on_string_content(*args); end
-
- def on_string_dvar(*args); end
-
- def on_string_embexpr(*args); end
-
- def on_string_literal(*args); end
-
- def on_super(*args); end
-
- def on_symbeg(tok); end
-
- def on_symbol(*args); end
-
- def on_symbol_literal(*args); end
-
- def on_symbols_add(*args); end
-
- def on_symbols_beg(tok); end
-
- def on_symbols_new(*args); end
-
- def on_tlambda(tok); end
-
- def on_tlambeg(tok); end
-
- def on_top_const_field(*args); end
-
- def on_top_const_ref(*args); end
-
- def on_tstring_beg(tok); end
-
- def on_tstring_content(tok); end
-
- def on_tstring_end(tok); end
-
- def on_unary(*args); end
-
- def on_undef(*args); end
-
- def on_unless(*args); end
-
- def on_unless_mod(*args); end
-
- def on_until(*args); end
-
- def on_until_mod(*args); end
-
- def on_var_alias(*args); end
-
- def on_var_field(*args); end
-
- def on_var_ref(*args); end
-
- def on_vcall(*args); end
-
- def on_void_stmt(*args); end
-
- def on_when(*args); end
-
- def on_while(*args); end
-
- def on_while_mod(*args); end
-
- def on_word_add(*args); end
-
- def on_word_new(*args); end
-
- def on_words_add(*args); end
-
- def on_words_beg(tok); end
-
- def on_words_new(*args); end
-
- def on_words_sep(tok); end
-
- def on_xstring_add(*args); end
-
- def on_xstring_literal(*args); end
-
- def on_xstring_new(*args); end
-
- def on_yield(*args); end
-
- def on_yield0(*args); end
-
- def on_zsuper(*args); end
-end
-
-class Ripper::TokenPattern
- def initialize(pattern); end
-
- def match(str); end
-
- def match_list(tokens); end
- MAP = ::T.let(nil, ::T.untyped)
-end
-
-class Ripper::TokenPattern::CompileError
-end
-
-class Ripper::TokenPattern::CompileError
-end
-
-class Ripper::TokenPattern::Error
-end
-
-class Ripper::TokenPattern::Error
-end
-
-class Ripper::TokenPattern::MatchData
- def initialize(tokens, match); end
-
- def string(n=T.unsafe(nil)); end
-end
-
-class Ripper::TokenPattern::MatchData
-end
-
-class Ripper::TokenPattern::MatchError
-end
-
-class Ripper::TokenPattern::MatchError
-end
-
-class Ripper::TokenPattern
- def self.compile(*arg); end
-end
-
-class Ripper
- def self.dedent_string(arg, arg1); end
-
- def self.lex_state_name(arg); end
-
- def self.token_match(src, pattern); end
-end
-
module RuboCop::AST::CollectionNode
def compact_blank(*args, &block); end
@@ -6407,223 +5875,6 @@ module Socket::Constants
TCP_NOPUSH = ::T.let(nil, ::T.untyped)
end
-class Spoom::Cli::Bump
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Cli::Helper
- HIGHLIGHT_COLOR = ::T.let(nil, ::T.untyped)
-end
-
-module Spoom::Cli::Helper
- extend ::T::Sig
- extend ::T::Helpers
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Cli::Main
- extend ::T::Sig
-end
-
-module Spoom::Colorize
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::D3::Base
- extend ::T::Sig
- extend ::T::Helpers
- extend ::T::Private::Abstract::Hooks
- extend ::T::InterfaceWrapper::Helpers
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Coverage::D3
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::Snapshot
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Coverage::Template
- extend ::T::Sig
- extend ::T::Helpers
- extend ::T::Private::Abstract::Hooks
- extend ::T::InterfaceWrapper::Helpers
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Coverage
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::FileTree::Node
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::FileTree
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Git
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Client
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Diagnostic
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::DocumentSymbol
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Error::Diagnostics
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Hover
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Location
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Message
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Position
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::LSP::PrintableSymbol
- extend ::T::Sig
- extend ::T::Helpers
- extend ::T::Private::Abstract::Hooks
- extend ::T::InterfaceWrapper::Helpers
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::Range
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::ResponseError
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::LSP::SignatureHelp
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Printer
- extend ::T::Sig
- extend ::T::Helpers
- extend ::T::Private::Abstract::Hooks
- extend ::T::InterfaceWrapper::Helpers
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Config
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Errors::Error
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Sorbet::Errors::Parser
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::Errors
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::MetricsParser
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet::Sigils
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom::Sorbet
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class Spoom::Timeline
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module Spoom
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
class String
def exclude?(string); end
@@ -6692,12 +5943,6 @@ class Tap
extend ::T::Private::Methods::SingletonMethodHooks
end
-module Tapioca
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
class Tempfile
def _close(); end
end
@@ -7319,72 +6564,6 @@ end
module Webrobots
end
-module YARDSorbet::Directives
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::AbstractDSLHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::EnumsHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::IncludeHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::MixesInClassMethodsHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::SigHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::Handlers::StructClassHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-class YARDSorbet::Handlers::StructPropHandler
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::NodeUtils
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::SigToYARD
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
-module YARDSorbet::TagUtils
- extend ::T::Sig
- extend ::T::Private::Methods::MethodHooks
- extend ::T::Private::Methods::SingletonMethodHooks
-end
-
class Zlib::Deflate
def initialize(*arg); end
end | false |
Other | Homebrew | brew | fb8a4e565836e33f2195ff49eaf10535d8bb78a0.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/Gemfile | @@ -6,6 +6,7 @@ source "https://rubygems.org"
# * nokogiri - use rexml instead for XML parsing
# installed gems (should all be require: false)
+gem "addressable", require: false
gem "bootsnap", require: false
gem "byebug", require: false
gem "json_schemer", require: false | true |
Other | Homebrew | brew | fb8a4e565836e33f2195ff49eaf10535d8bb78a0.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/Gemfile.lock | @@ -201,6 +201,7 @@ PLATFORMS
DEPENDENCIES
activesupport (< 7)
+ addressable
bootsnap
byebug
concurrent-ruby | true |
Other | Homebrew | brew | fb8a4e565836e33f2195ff49eaf10535d8bb78a0.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/livecheck/livecheck.rb | @@ -5,6 +5,7 @@
require "livecheck/livecheck_version"
require "livecheck/skip_conditions"
require "livecheck/strategy"
+require "addressable"
require "ruby-progressbar"
require "uri"
@@ -529,26 +530,33 @@ def preprocess_url(url)
url
end
- # Fetch with brewed curl if using the download or homepage URL
- # and the download URL specifies `using: :homebrew_curl`.
+ # livecheck should fetch a URL using brewed curl if the formula/cask
+ # contains a `stable`/`url` or `head` URL `using: :homebrew_curl` that
+ # shares the same root domain.
sig { params(formula_or_cask: T.any(Formula, Cask::Cask), url: String).returns(T::Boolean) }
def use_homebrew_curl?(formula_or_cask, url)
- if checkable_urls(formula_or_cask).include?(url)
- case formula_or_cask
- when Formula
- [:stable, :head].any? do |spec_name|
- next false unless (spec = formula_or_cask.send(spec_name))
+ url_root_domain = Addressable::URI.parse(url)&.domain
+ return false if url_root_domain.blank?
- spec.using == :homebrew_curl
- end
- when Cask::Cask
- formula_or_cask.url.using == :homebrew_curl
- else
- T.absurd(formula_or_cask)
+ # Collect root domains of URLs with `using: :homebrew_curl`
+ homebrew_curl_root_domains = []
+ case formula_or_cask
+ when Formula
+ [:stable, :head].each do |spec_name|
+ next unless (spec = formula_or_cask.send(spec_name))
+ next unless spec.using == :homebrew_curl
+
+ domain = Addressable::URI.parse(spec.url)&.domain
+ homebrew_curl_root_domains << domain if domain.present?
end
- else
- false
+ when Cask::Cask
+ return false unless formula_or_cask.url.using == :homebrew_curl
+
+ domain = Addressable::URI.parse(formula_or_cask.url.to_s)&.domain
+ homebrew_curl_root_domains << domain if domain.present?
end
+
+ homebrew_curl_root_domains.include?(url_root_domain)
end
# Identifies the latest version of the formula and returns a Hash containing
@@ -662,6 +670,7 @@ def latest_version(
when "PageMatch", "HeaderMatch"
use_homebrew_curl?((referenced_formula_or_cask || formula_or_cask), url)
end
+ puts "Homebrew curl?: Yes" if debug && homebrew_curl.present?
strategy_data = strategy.find_versions(
url: url,
@@ -743,6 +752,7 @@ def latest_version(
version_info[:meta][:url][:strategy] = strategy_data[:url]
end
version_info[:meta][:url][:final] = strategy_data[:final_url] if strategy_data[:final_url]
+ version_info[:meta][:url][:homebrew_curl] = homebrew_curl if homebrew_curl.present?
version_info[:meta][:strategy] = strategy.present? ? strategy_name : nil
version_info[:meta][:strategies] = strategies.map { |s| livecheck_strategy_names[s] } if strategies.present? | true |
Other | Homebrew | brew | fb8a4e565836e33f2195ff49eaf10535d8bb78a0.json | Livecheck: Use Homebrew curl based on root domain
At the moment, `#use_homebrew_curl?` can only be true for a
`homepage` or `stable`/cask `url` with `using: :homebrew_curl`. If
the checked URL differs from these URLs, livecheck won't use brewed
curl. This limitation prevents livecheck from using brewed curl for a
`livecheck` block URL that's a string literal (not a symbol for a
`#checkable_url` like `:stable`, `:head`, `:url`). `libzip` was the
original formula referenced in the related brew issue and it meets
this criterion, so it doesn't appear to be handled by the existing
`#use_homebrew_curl?` implementation.
Additionally, the existing behavior can cause livecheck to
unnecessarily use brewed curl for a completely different website
(e.g., `cubelib`, `otf2`). For example, if the `stable` URL has
`using: :homebrew_curl` and the `livecheck` block has `url
:homepage`, livecheck will use brewed curl when checking the
`homepage`. If these are completely different domains/servers, it's
unlikely that we would need to use brewed curl when checking the
`homepage`, so this particular behavior may not be beneficial.
This commit reimplements `use_homebrew_curl?` to apply brewed curl
when the checked URL's root domain is the same as the root domain of
an aforementioned formula/cask URL with `using: :homebrew_curl`. For
example, this looser approach would allow a `livecheck` block
checking `https://www.example.com/downloads/` to use brewed curl if
the `stable` URL was `https://downloads.example.com/example.zip` with
`using: :homebrew_curl`. These could be different servers but, based
on related formulae, this looseness is necessary for the moment.
This approach aims to resolve both issues, allowing brewed curl to be
applied to a slightly broader range of URLs (i.e., not limited to
just the `#checkable_urls`) while also helping to avoid unnecessarily
applying brewed curl when it's less likely to be useful (completely
different domains). Neither approach is perfect but this one may be
more useful in the interim time.
Depending on how this looser approach works in practice, we may want
to consider returning to a stricter approach once we have something
like `using: :homebrew_curl` in `livecheck` blocks (this is
forthcoming). Being explicit in a `livecheck` block is the most
reliable approach (i.e., only use brewed curl when needed), so we
could favor that and pare down the automated approach to only what's
needed to support implicit checks (i.e., with no `livecheck` block).
Of course, it's also possible to drop the automated approach entirely
and simply require a `livecheck` block in this scenario but we can
decide on how to handle this when the time comes. | Library/Homebrew/test/livecheck/livecheck_spec.rb | @@ -16,7 +16,7 @@
formula("test") do
desc "Test formula"
homepage "https://brew.sh"
- url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
+ url "https://brew.sh/test-0.0.1.tgz"
head "https://github.com/Homebrew/brew.git"
livecheck do
@@ -31,7 +31,7 @@
cask "test" do
version "0.0.1,2"
- url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
+ url "https://brew.sh/test-0.0.1.dmg"
name "Test"
desc "Test cask"
homepage "https://brew.sh"
@@ -158,13 +158,67 @@
end
describe "::use_homebrew_curl?" do
- it "uses brewed curl if called for by the download URL" do
+ let(:example_url) { "https://www.example.com/test-0.0.1.tgz" }
+
+ let(:f_homebrew_curl) do
+ formula("test") do
+ desc "Test formula"
+ homepage "https://brew.sh"
+ url "https://brew.sh/test-0.0.1.tgz", using: :homebrew_curl
+ # head is deliberably omitted to exercise more of the method
+
+ livecheck do
+ url "https://formulae.brew.sh/api/formula/ruby.json"
+ regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+ end
+ end
+ end
+
+ let(:c_homebrew_curl) do
+ Cask::CaskLoader.load(+<<-RUBY)
+ cask "test" do
+ version "0.0.1,2"
+
+ url "https://brew.sh/test-0.0.1.dmg", using: :homebrew_curl
+ name "Test"
+ desc "Test cask"
+ homepage "https://brew.sh"
+
+ livecheck do
+ url "https://formulae.brew.sh/api/formula/ruby.json"
+ regex(/"stable":"(\d+(?:\.\d+)+)"/i)
+ end
+ end
+ RUBY
+ end
+
+ it "returns `true` when URL matches a `using: :homebrew_curl` URL" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, livecheck_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, stable_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, livecheck_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, homepage_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, cask_url)).to be(true)
+ end
+
+ it "returns `false` if URL root domain differs from `using: :homebrew_curl` URLs" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, example_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c_homebrew_curl, example_url)).to be(false)
+ end
+
+ it "returns `false` if a `using: homebrew_curl` URL is not present" do
expect(livecheck.use_homebrew_curl?(f, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(f, homepage_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(f, stable_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(f, example_url)).to be(false)
expect(livecheck.use_homebrew_curl?(c, livecheck_url)).to be(false)
- expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(true)
- expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(true)
+ expect(livecheck.use_homebrew_curl?(c, homepage_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c, cask_url)).to be(false)
+ expect(livecheck.use_homebrew_curl?(c, example_url)).to be(false)
+ end
+
+ it "returns `false` if URL string does not contain a domain" do
+ expect(livecheck.use_homebrew_curl?(f_homebrew_curl, "test")).to be(false)
end
end
| true |
Other | Homebrew | brew | bf34f2106554de49a8d64a0fc17edfb045c29f06.json | style: use long shfmt arguments.
This allows removing documentation explaining them. | Library/Homebrew/style.rb | @@ -240,16 +240,8 @@ def run_shfmt(files, fix: false)
files.delete(HOMEBREW_REPOSITORY/"completions/bash/brew")
files.delete(HOMEBREW_REPOSITORY/"Dockerfile")
- # shfmt options:
- # -i 2 : indent by 2 spaces
- # -ci : indent switch cases
- # -ln bash : language variant to parse ("bash")
- # -w : write result to file instead of stdout (inplace fixing)
- # "--" is needed for `utils/shfmt.sh`
- args = ["-i", "2", "-ci", "-ln", "bash", "--", *files]
-
- # Do inplace fixing
- args.unshift("-w") if fix # need to add before "--"
+ args = ["--language-dialect", "bash", "--indent", "2", "--case-indent", "--", *files]
+ args.unshift("--write") if fix # need to add before "--"
system shfmt, *args
$CHILD_STATUS.success? | false |
Other | Homebrew | brew | ecc705803f0d78b5a702a313d247c59135016347.json | github_packages: add comment for image-spec pin | Library/Homebrew/github_packages.rb | @@ -151,6 +151,9 @@ def load_schemas!
end
def schema_uri(basename, uris)
+ # The current `main` version has an invalid JSON schema.
+ # Going forward, this should probably be pinned to tags.
+ # We currently use features newer than the last one (v1.0.2).
url = "https://raw.githubusercontent.com/opencontainers/image-spec/170393e57ed656f7f81c3070bfa8c3346eaa0a5a/schema/#{basename}.json"
out, = curl_output(url)
json = JSON.parse(out) | false |
Other | Homebrew | brew | c66740c5ad4e6b8be9eab296f5612260f93deff0.json | Update RBI files for regexp_parser. | Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.4.0.rbi | @@ -92,6 +92,7 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
end
class Regexp::Expression::Base
+ include ::Regexp::Expression::Shared
include ::RuboCop::Ext::RegexpParser::Expression::Base
def initialize(token, options = T.unsafe(nil)); end
@@ -100,20 +101,16 @@ class Regexp::Expression::Base
def a?; end
def ascii_classes?; end
def attributes; end
- def base_length; end
def case_insensitive?; end
- def coded_offset; end
def conditional_level; end
def conditional_level=(_arg0); end
def d?; end
def default_classes?; end
def extended?; end
def free_spacing?; end
- def full_length; end
def greedy?; end
def i?; end
def ignore_case?; end
- def is?(test_token, test_type = T.unsafe(nil)); end
def lazy?; end
def level; end
def level=(_arg0); end
@@ -123,38 +120,31 @@ class Regexp::Expression::Base
def matches?(string); end
def multiline?; end
def nesting_level; end
- def nesting_level=(_arg0); end
- def offset; end
- def one_of?(scope, top = T.unsafe(nil)); end
def options; end
def options=(_arg0); end
def possessive?; end
- def quantified?; end
def quantifier; end
def quantifier=(_arg0); end
- def quantifier_affix(expression_format); end
- def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
+ def quantify(*args); end
def quantity; end
def reluctant?; end
def repetitions; end
def set_level; end
def set_level=(_arg0); end
- def starts_at; end
def strfre(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
def strfregexp(format = T.unsafe(nil), indent_offset = T.unsafe(nil), index = T.unsafe(nil)); end
- def terminal?; end
+ def te; end
+ def te=(_arg0); end
def text; end
def text=(_arg0); end
def to_h; end
def to_re(format = T.unsafe(nil)); end
- def to_s(format = T.unsafe(nil)); end
def token; end
def token=(_arg0); end
def ts; end
def ts=(_arg0); end
def type; end
def type=(_arg0); end
- def type?(test_type); end
def u?; end
def unicode_classes?; end
def unquantified_clone; end
@@ -180,7 +170,7 @@ class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
def negative; end
def negative=(_arg0); end
def negative?; end
- def to_s(format = T.unsafe(nil)); end
+ def parts; end
end
class Regexp::Expression::CharacterSet::IntersectedSequence < ::Regexp::Expression::Sequence
@@ -197,8 +187,8 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
def <<(exp); end
def complete?; end
def match_length; end
+ def parts; end
def starts_at; end
- def to_s(_format = T.unsafe(nil)); end
def ts; end
end
@@ -242,10 +232,10 @@ class Regexp::Expression::Conditional::Expression < ::Regexp::Expression::Subexp
def condition; end
def condition=(exp); end
def match_length; end
+ def parts; end
def reference; end
def referenced_expression; end
def referenced_expression=(_arg0); end
- def to_s(format = T.unsafe(nil)); end
private
@@ -318,7 +308,7 @@ class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::Es
class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
def match_length; end
- def quantify(_token, _text, _min = T.unsafe(nil), _max = T.unsafe(nil), _mode = T.unsafe(nil)); end
+ def quantify(*_args); end
end
module Regexp::Expression::Group; end
@@ -332,7 +322,7 @@ class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
def capturing?; end
def comment?; end
- def to_s(format = T.unsafe(nil)); end
+ def parts; end
end
class Regexp::Expression::Group::Capture < ::Regexp::Expression::Group::Base
@@ -346,7 +336,7 @@ end
class Regexp::Expression::Group::Comment < ::Regexp::Expression::Group::Base
def comment?; end
- def to_s(_format = T.unsafe(nil)); end
+ def parts; end
end
class Regexp::Expression::Group::Named < ::Regexp::Expression::Group::Capture
@@ -374,7 +364,7 @@ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
def implicit=(_arg0); end
def implicit?; end
- def to_s(format = T.unsafe(nil)); end
+ def parts; end
end
module Regexp::Expression::Keep; end
@@ -396,26 +386,44 @@ class Regexp::Expression::PosixClass < ::Regexp::Expression::Base
end
class Regexp::Expression::Quantifier
- def initialize(token, text, min, max, mode); end
+ include ::Regexp::Expression::Shared
- def ==(other); end
- def eq(other); end
+ def initialize(*args); end
+
+ def conditional_level; end
+ def conditional_level=(_arg0); end
def greedy?; end
def lazy?; end
+ def level; end
+ def level=(_arg0); end
def max; end
def min; end
def mode; end
+ def nesting_level; end
+ def options; end
+ def options=(_arg0); end
def possessive?; end
+ def quantifier; end
+ def quantifier=(_arg0); end
def reluctant?; end
+ def set_level; end
+ def set_level=(_arg0); end
+ def te; end
+ def te=(_arg0); end
def text; end
+ def text=(_arg0); end
def to_h; end
- def to_s; end
- def to_str; end
def token; end
+ def token=(_arg0); end
+ def ts; end
+ def ts=(_arg0); end
+ def type; end
+ def type=(_arg0); end
private
- def initialize_copy(orig); end
+ def deprecated_old_init(token, text, min, max, mode = T.unsafe(nil)); end
+ def minmax; end
end
Regexp::Expression::Quantifier::MODES = T.let(T.unsafe(nil), Array)
@@ -428,7 +436,7 @@ class Regexp::Expression::Root < ::Regexp::Expression::Subexpression
end
class Regexp::Expression::Sequence < ::Regexp::Expression::Subexpression
- def quantify(token, text, min = T.unsafe(nil), max = T.unsafe(nil), mode = T.unsafe(nil)); end
+ def quantify(*args); end
def starts_at; end
def ts; end
@@ -443,12 +451,42 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio
def add_sequence(active_opts = T.unsafe(nil)); end
def operands; end
def operator; end
+ def parts; end
def sequences; end
def starts_at; end
- def to_s(format = T.unsafe(nil)); end
def ts; end
end
+module Regexp::Expression::Shared
+ def ==(other); end
+ def ===(other); end
+ def base_length; end
+ def coded_offset; end
+ def eql?(other); end
+ def full_length; end
+ def is?(test_token, test_type = T.unsafe(nil)); end
+ def nesting_level=(lvl); end
+ def offset; end
+ def one_of?(scope, top = T.unsafe(nil)); end
+ def parts; end
+ def quantified?; end
+ def quantifier_affix(expression_format); end
+ def starts_at; end
+ def terminal?; end
+ def to_s(format = T.unsafe(nil)); end
+ def to_str(format = T.unsafe(nil)); end
+ def type?(test_type); end
+
+ private
+
+ def init_from_token_and_options(token, options = T.unsafe(nil)); end
+ def initialize_copy(orig); end
+
+ class << self
+ def included(mod); end
+ end
+end
+
class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
include ::Enumerable
@@ -471,18 +509,19 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
def last(*args, &block); end
def length(*args, &block); end
def match_length; end
+ def parts; end
def strfre_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
def strfregexp_tree(format = T.unsafe(nil), include_self = T.unsafe(nil), separator = T.unsafe(nil)); end
def te; end
def to_h; end
- def to_s(format = T.unsafe(nil)); end
def traverse(include_self = T.unsafe(nil), &block); end
def values_at(*args, &block); end
def walk(include_self = T.unsafe(nil), &block); end
private
def initialize_copy(orig); end
+ def intersperse(expressions, separator); end
end
module Regexp::Expression::UnicodeProperty; end
@@ -670,9 +709,8 @@ class Regexp::Parser
def extract_options(input, options); end
def free_space(token); end
def group(token); end
- def increase_level(exp); end
+ def increase_group_level(exp); end
def intersection(token); end
- def interval(target_node, token); end
def keep(token); end
def literal(token); end
def meta(token); end
@@ -701,7 +739,6 @@ class Regexp::Parser
def switching_options=(_arg0); end
def total_captured_group_count; end
def type(token); end
- def update_transplanted_subtree(exp, new_parent); end
class << self
def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
@@ -756,11 +793,12 @@ class Regexp::Scanner
def spacing_stack=(_arg0); end
def tokens; end
def tokens=(_arg0); end
- def validation_error(type, what, reason); end
+ def validation_error(type, what, reason = T.unsafe(nil)); end
class << self
def long_prop_map; end
def parse_prop_map(name); end
+ def posix_classes; end
def scan(input_object, options: T.unsafe(nil), &block); end
def short_prop_map; end
end
@@ -788,6 +826,10 @@ end
class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
+class Regexp::Scanner::UnknownPosixClassError < ::Regexp::Scanner::ValidationError
+ def initialize(text); end
+end
+
class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
def initialize(name); end
end | false |
Other | Homebrew | brew | 114a8c75225ce9029ffbfb92ec44f5d3924580a1.json | Update RBI files for parlour. | Library/Homebrew/sorbet/rbi/gems/parlour@8.0.0.rbi | @@ -148,7 +148,7 @@ module Parlour::Mixin::Searchable
abstract!
- Child = type_member
+ Child = type_member { { upper: Parlour::TypedObject } }
sig { abstract.returns(T::Array[Child]) }
def children; end | false |
Other | Homebrew | brew | 96785e13867bbdbb798c6319f7ac01ac1d4984fb.json | Update RBI files for activesupport. | Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.6.rbi | @@ -2784,7 +2784,6 @@ end
module ActiveSupport::VERSION; end
ActiveSupport::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
ActiveSupport::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActiveSupport::VERSION::PRE = T.let(T.unsafe(nil), String)
ActiveSupport::VERSION::STRING = T.let(T.unsafe(nil), String)
ActiveSupport::VERSION::TINY = T.let(T.unsafe(nil), Integer)
| true |
Other | Homebrew | brew | 96785e13867bbdbb798c6319f7ac01ac1d4984fb.json | Update RBI files for activesupport. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -24,6 +24,10 @@ module ActiveSupport::ForkTracker::CoreExtPrivate
include ::ActiveSupport::ForkTracker::CoreExt
end
+module ActiveSupport::VERSION
+ PRE = ::T.let(nil, ::T.untyped)
+end
+
class Addrinfo
def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
end | true |
Other | Homebrew | brew | bd2d7d92cad7d99a629d4c9cd5abdb2d146d731d.json | Update RBI files for sorbet. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -2144,60 +2144,6 @@ end
Gem::Security::KEY_ALGORITHM = OpenSSL::PKey::RSA
-class Gem::Security::Policy
- include ::Gem::UserInteraction
- include ::Gem::DefaultUserInteraction
- include ::Gem::Text
- def check_cert(signer, issuer, time); end
-
- def check_chain(chain, time); end
-
- def check_data(public_key, digest, signature, data); end
-
- def check_key(signer, key); end
-
- def check_root(chain, time); end
-
- def check_trust(chain, digester, trust_dir); end
-
- def initialize(name, policy=T.unsafe(nil), opt=T.unsafe(nil)); end
-
- def name(); end
-
- def only_signed(); end
-
- def only_signed=(only_signed); end
-
- def only_trusted(); end
-
- def only_trusted=(only_trusted); end
-
- def subject(certificate); end
-
- def verify(chain, key=T.unsafe(nil), digests=T.unsafe(nil), signatures=T.unsafe(nil), full_name=T.unsafe(nil)); end
-
- def verify_chain(); end
-
- def verify_chain=(verify_chain); end
-
- def verify_data(); end
-
- def verify_data=(verify_data); end
-
- def verify_root(); end
-
- def verify_root=(verify_root); end
-
- def verify_signatures(spec, digests, signatures); end
-
- def verify_signer(); end
-
- def verify_signer=(verify_signer); end
-end
-
-class Gem::Security::Policy
-end
-
class Gem::Security::Signer
include ::Gem::UserInteraction
include ::Gem::DefaultUserInteraction | false |
Other | Homebrew | brew | 40b8fd3406b2c50873f021f0787f7c253acd009e.json | url_protected_by_*: Check multiple headers
Before `#parse_curl_output` was introduced and related methods were
updated to use it, `#url_protected_by_cloudflare?` and
`#url_protected_by_incapsula?` were checking a string of all the
headers from a response and using a regex to check related header
values.
However, when `#curl_http_content_headers_and_checksum` was updated
to use `#parse_curl_output` internally, the `:headers` value became
a hash generated by `#parse_curl_response`. The `#url_protected_by_*`
methods were updated to work with the hash value but this wasn't able
to fully replicate the previous behavior because
`#parse_curl_response` was only keeping the last instance of a given
header (maintaining pre-existing behavior). This is an issue for
these methods because they check `Set-Cookie` headers and there can
be multiple instances of this header in a response.
This commit updates these methods to handle an array of strings in
addition to the existing string support. This change ensures that
these methods properly check all `Set-Cookie` headers, effectively
reinstating the previous behavior.
Past that, this updates one of the early return values in
`#url_protected_by_cloudflare?` to be `false` instead of an implicit
`nil`. After adding a type signature to this method, it became clear
that it wasn't always returning a boolean value and this fixes it. | Library/Homebrew/test/utils/curl_spec.rb | @@ -4,6 +4,115 @@
require "utils/curl"
describe "Utils::Curl" do
+ let(:details) {
+ details = {
+ normal: {},
+ cloudflare: {},
+ incapsula: {},
+ }
+
+ details[:normal][:no_cookie] = {
+ url: "https://www.example.com/",
+ final_url: nil,
+ status: "403",
+ headers: {
+ "age" => "123456",
+ "cache-control" => "max-age=604800",
+ "content-type" => "text/html; charset=UTF-8",
+ "date" => "Wed, 1 Jan 2020 01:23:45 GMT",
+ "etag" => "\"3147526947+ident\"",
+ "expires" => "Wed, 31 Jan 2020 01:23:45 GMT",
+ "last-modified" => "Wed, 1 Jan 2020 00:00:00 GMT",
+ "server" => "ECS (dcb/7EA2)",
+ "vary" => "Accept-Encoding",
+ "x-cache" => "HIT",
+ "content-length" => "3",
+ },
+ etag: "3147526947+ident",
+ content_length: "3",
+ file: "...",
+ file_hash: nil,
+ }
+
+ details[:normal][:ok] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:normal][:ok][:status] = "200"
+
+ details[:normal][:single_cookie] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:normal][:single_cookie][:headers]["set-cookie"] = "a_cookie=for_testing"
+
+ details[:normal][:multiple_cookies] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:normal][:multiple_cookies][:headers]["set-cookie"] = [
+ "first_cookie=for_testing",
+ "last_cookie=also_for_testing",
+ ]
+
+ details[:normal][:blank_headers] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:normal][:blank_headers][:headers] = {}
+
+ details[:cloudflare][:single_cookie] = {
+ url: "https://www.example.com/",
+ final_url: nil,
+ status: "403",
+ headers: {
+ "date" => "Wed, 1 Jan 2020 01:23:45 GMT",
+ "content-type" => "text/plain; charset=UTF-8",
+ "content-length" => "16",
+ "x-frame-options" => "SAMEORIGIN",
+ "referrer-policy" => "same-origin",
+ "cache-control" => "private, max-age=0, no-store, no-cache, must-revalidate, post-check=0, pre-check=0",
+ "expires" => "Thu, 01 Jan 1970 00:00:01 GMT",
+ "expect-ct" => "max-age=604800, report-uri=\"https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct\"",
+ "set-cookie" => "__cf_bm=0123456789abcdef; path=/; expires=Wed, 31-Jan-20 01:23:45 GMT;" \
+ " domain=www.example.com; HttpOnly; Secure; SameSite=None",
+ "server" => "cloudflare",
+ "cf-ray" => "0123456789abcdef-IAD",
+ "alt-svc" => "h3=\":443\"; ma=86400, h3-29=\":443\"; ma=86400",
+ },
+ etag: nil,
+ content_length: "16",
+ file: "error code: 1020",
+ file_hash: nil,
+ }
+
+ details[:cloudflare][:multiple_cookies] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+ details[:cloudflare][:multiple_cookies][:headers]["set-cookie"] = [
+ "first_cookie=for_testing",
+ "__cf_bm=abcdef0123456789; path=/; expires=Thu, 28-Apr-22 18:38:40 GMT; domain=www.example.com; HttpOnly;" \
+ " Secure; SameSite=None",
+ "last_cookie=also_for_testing",
+ ]
+
+ details[:cloudflare][:no_server] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+ details[:cloudflare][:no_server][:headers].delete("server")
+
+ details[:cloudflare][:wrong_server] = Marshal.load(Marshal.dump(details[:cloudflare][:single_cookie]))
+ details[:cloudflare][:wrong_server][:headers]["server"] = "nginx 1.2.3"
+
+ # TODO: Make the Incapsula test data more realistic once we can find an
+ # example website to reference.
+ details[:incapsula][:single_cookie_visid_incap] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:incapsula][:single_cookie_visid_incap][:headers]["set-cookie"] = "visid_incap_something=something"
+
+ details[:incapsula][:single_cookie_incap_ses] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:incapsula][:single_cookie_incap_ses][:headers]["set-cookie"] = "incap_ses_something=something"
+
+ details[:incapsula][:multiple_cookies_visid_incap] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:incapsula][:multiple_cookies_visid_incap][:headers]["set-cookie"] = [
+ "first_cookie=for_testing",
+ "visid_incap_something=something",
+ "last_cookie=also_for_testing",
+ ]
+
+ details[:incapsula][:multiple_cookies_incap_ses] = Marshal.load(Marshal.dump(details[:normal][:no_cookie]))
+ details[:incapsula][:multiple_cookies_incap_ses][:headers]["set-cookie"] = [
+ "first_cookie=for_testing",
+ "incap_ses_something=something",
+ "last_cookie=also_for_testing",
+ ]
+
+ details
+ }
+
let(:location_urls) {
%w[
https://example.com/example/
@@ -294,6 +403,46 @@
end
end
+ describe "url_protected_by_cloudflare?" do
+ it "returns `true` when a URL is protected by Cloudflare" do
+ expect(url_protected_by_cloudflare?(details[:cloudflare][:single_cookie])).to be(true)
+ expect(url_protected_by_cloudflare?(details[:cloudflare][:multiple_cookies])).to be(true)
+ end
+
+ it "returns `false` when a URL is not protected by Cloudflare" do
+ expect(url_protected_by_cloudflare?(details[:cloudflare][:no_server])).to be(false)
+ expect(url_protected_by_cloudflare?(details[:cloudflare][:wrong_server])).to be(false)
+ expect(url_protected_by_cloudflare?(details[:normal][:no_cookie])).to be(false)
+ expect(url_protected_by_cloudflare?(details[:normal][:ok])).to be(false)
+ expect(url_protected_by_cloudflare?(details[:normal][:single_cookie])).to be(false)
+ expect(url_protected_by_cloudflare?(details[:normal][:multiple_cookies])).to be(false)
+ end
+
+ it "returns `false` when response headers are blank" do
+ expect(url_protected_by_cloudflare?(details[:normal][:blank_headers])).to be(false)
+ end
+ end
+
+ describe "url_protected_by_incapsula?" do
+ it "returns `true` when a URL is protected by Cloudflare" do
+ expect(url_protected_by_incapsula?(details[:incapsula][:single_cookie_visid_incap])).to be(true)
+ expect(url_protected_by_incapsula?(details[:incapsula][:single_cookie_incap_ses])).to be(true)
+ expect(url_protected_by_incapsula?(details[:incapsula][:multiple_cookies_visid_incap])).to be(true)
+ expect(url_protected_by_incapsula?(details[:incapsula][:multiple_cookies_incap_ses])).to be(true)
+ end
+
+ it "returns `false` when a URL is not protected by Incapsula" do
+ expect(url_protected_by_incapsula?(details[:normal][:no_cookie])).to be(false)
+ expect(url_protected_by_incapsula?(details[:normal][:ok])).to be(false)
+ expect(url_protected_by_incapsula?(details[:normal][:single_cookie])).to be(false)
+ expect(url_protected_by_incapsula?(details[:normal][:multiple_cookies])).to be(false)
+ end
+
+ it "returns `false` when response headers are blank" do
+ expect(url_protected_by_incapsula?(details[:normal][:blank_headers])).to be(false)
+ end
+ end
+
describe "#parse_curl_output" do
it "returns a correct hash when curl output contains response(s) and body" do
expect(parse_curl_output("#{response_text[:ok]}#{body[:default]}")) | true |
Other | Homebrew | brew | 40b8fd3406b2c50873f021f0787f7c253acd009e.json | url_protected_by_*: Check multiple headers
Before `#parse_curl_output` was introduced and related methods were
updated to use it, `#url_protected_by_cloudflare?` and
`#url_protected_by_incapsula?` were checking a string of all the
headers from a response and using a regex to check related header
values.
However, when `#curl_http_content_headers_and_checksum` was updated
to use `#parse_curl_output` internally, the `:headers` value became
a hash generated by `#parse_curl_response`. The `#url_protected_by_*`
methods were updated to work with the hash value but this wasn't able
to fully replicate the previous behavior because
`#parse_curl_response` was only keeping the last instance of a given
header (maintaining pre-existing behavior). This is an issue for
these methods because they check `Set-Cookie` headers and there can
be multiple instances of this header in a response.
This commit updates these methods to handle an array of strings in
addition to the existing string support. This change ensures that
these methods properly check all `Set-Cookie` headers, effectively
reinstating the previous behavior.
Past that, this updates one of the early return values in
`#url_protected_by_cloudflare?` to be `false` instead of an implicit
`nil`. After adding a type signature to this method, it became clear
that it wasn't always returning a boolean value and this fixes it. | Library/Homebrew/utils/curl.rb | @@ -198,20 +198,40 @@ def curl_output(*args, **options)
end
# Check if a URL is protected by CloudFlare (e.g. badlion.net and jaxx.io).
+ # @param details [Hash] Response information from
+ # `#curl_http_content_headers_and_checksum`.
+ # @return [true, false] Whether a response contains headers indicating that
+ # the URL is protected by Cloudflare.
+ sig { params(details: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
def url_protected_by_cloudflare?(details)
return false if details[:headers].blank?
- return unless [403, 503].include?(details[:status].to_i)
+ return false unless [403, 503].include?(details[:status].to_i)
- details[:headers].fetch("set-cookie", nil)&.match?(/^(__cfduid|__cf_bm)=/i) &&
- details[:headers].fetch("server", nil)&.match?(/^cloudflare/i)
+ set_cookie_header = Array(details[:headers]["set-cookie"])
+ has_cloudflare_cookie_header = set_cookie_header.compact.any? do |cookie|
+ cookie.match?(/^(__cfduid|__cf_bm)=/i)
+ end
+
+ server_header = Array(details[:headers]["server"])
+ has_cloudflare_server = server_header.compact.any? do |server|
+ server.match?(/^cloudflare/i)
+ end
+
+ has_cloudflare_cookie_header && has_cloudflare_server
end
# Check if a URL is protected by Incapsula (e.g. corsair.com).
+ # @param details [Hash] Response information from
+ # `#curl_http_content_headers_and_checksum`.
+ # @return [true, false] Whether a response contains headers indicating that
+ # the URL is protected by Incapsula.
+ sig { params(details: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
def url_protected_by_incapsula?(details)
return false if details[:headers].blank?
return false if details[:status].to_i != 403
- details[:headers].fetch("set-cookie", nil)&.match?(/^(visid_incap|incap_ses)_/i)
+ set_cookie_header = Array(details[:headers]["set-cookie"])
+ set_cookie_header.compact.any? { |cookie| cookie.match?(/^(visid_incap|incap_ses)_/i) }
end
def curl_check_http_content(url, url_type, specs: {}, user_agents: [:default], | true |
Other | Homebrew | brew | 94449d07c07bb9d858ea11b097d1d2fd33bca187.json | parse_curl_response: Handle duplicate headers
`Curl#parse_curl_response` only includes the last instance of a given
header in its `:headers` hash (replicating pre-existing behavior).
This is a problem for headers like `Set-Cookie`, which can appear more
than once in a response.
This commit addresses the issue by collecting duplicate headers into
an array instead. Headers that only appear once in the response will
still have a string value but headers that appear more than once will
be an array of strings. Whenever headers from `#parse_curl_response`
are used (directly or indirectly), it's important to conditionally
handle the expected types. | Library/Homebrew/test/utils/curl_spec.rb | @@ -112,6 +112,24 @@
},
}
+ response_hash[:duplicate_header] = {
+ status_code: "200",
+ status_text: "OK",
+ headers: {
+ "cache-control" => "max-age=604800",
+ "content-type" => "text/html; charset=UTF-8",
+ "date" => "Wed, 1 Jan 2020 01:23:45 GMT",
+ "expires" => "Wed, 31 Jan 2020 01:23:45 GMT",
+ "last-modified" => "Thu, 1 Jan 2019 01:23:45 GMT",
+ "content-length" => "123",
+ "set-cookie" => [
+ "example1=first",
+ "example2=second; Expires Wed, 31 Jan 2020 01:23:45 GMT",
+ "example3=third",
+ ],
+ },
+ }
+
response_hash
}
@@ -144,6 +162,13 @@
#{response_text[:ok]}
EOS
+ response_text[:duplicate_header] = response_text[:ok].sub(
+ /\r\n\Z/,
+ "Set-Cookie: #{response_hash[:duplicate_header][:headers]["set-cookie"][0]}\r\n" \
+ "Set-Cookie: #{response_hash[:duplicate_header][:headers]["set-cookie"][1]}\r\n" \
+ "Set-Cookie: #{response_hash[:duplicate_header][:headers]["set-cookie"][2]}\r\n\r\n",
+ )
+
response_text
}
@@ -312,6 +337,7 @@
it "returns a correct hash when given HTTP response text" do
expect(parse_curl_response(response_text[:ok])).to eq(response_hash[:ok])
expect(parse_curl_response(response_text[:redirection])).to eq(response_hash[:redirection])
+ expect(parse_curl_response(response_text[:duplicate_header])).to eq(response_hash[:duplicate_header])
end
it "returns an empty hash when given an empty string" do | true |
Other | Homebrew | brew | 94449d07c07bb9d858ea11b097d1d2fd33bca187.json | parse_curl_response: Handle duplicate headers
`Curl#parse_curl_response` only includes the last instance of a given
header in its `:headers` hash (replicating pre-existing behavior).
This is a problem for headers like `Set-Cookie`, which can appear more
than once in a response.
This commit addresses the issue by collecting duplicate headers into
an array instead. Headers that only appear once in the response will
still have a string value but headers that appear more than once will
be an array of strings. Whenever headers from `#parse_curl_response`
are used (directly or indirectly), it's important to conditionally
handle the expected types. | Library/Homebrew/utils/curl.rb | @@ -484,10 +484,25 @@ def parse_curl_response(response_text)
response_text = response_text.sub(%r{^HTTP/.* (\d+).*$\s*}, "")
# Create a hash from the header lines
- response[:headers] =
- response_text.split("\r\n")
- .to_h { |header| header.split(/:\s*/, 2) }
- .transform_keys(&:downcase)
+ response[:headers] = {}
+ response_text.split("\r\n").each do |line|
+ header_name, header_value = line.split(/:\s*/, 2)
+ next if header_name.blank?
+
+ header_name = header_name.strip.downcase
+ header_value&.strip!
+
+ case response[:headers][header_name]
+ when nil
+ response[:headers][header_name] = header_value
+ when String
+ response[:headers][header_name] = [response[:headers][header_name], header_value]
+ when Array
+ response[:headers][header_name].push(header_value)
+ end
+
+ response[:headers][header_name]
+ end
response
end | true |
Other | Homebrew | brew | b886b2d1f71813700b1b84aa8a29a89a5c472808.json | Remove mentions of nonexistent command `brew diy`
The output of `brew doctor` can mention a command `brew diy`, which no
longer exists. | Library/Homebrew/cmd/link.rb | @@ -84,7 +84,7 @@ def link
formula = begin
keg.to_formula
rescue FormulaUnavailableError
- # Not all kegs may belong to formulae e.g. with `brew diy`
+ # Not all kegs may belong to formulae
nil
end
| true |
Other | Homebrew | brew | b886b2d1f71813700b1b84aa8a29a89a5c472808.json | Remove mentions of nonexistent command `brew diy`
The output of `brew doctor` can mention a command `brew diy`, which no
longer exists. | Library/Homebrew/diagnostic.rb | @@ -900,7 +900,7 @@ def check_deleted_formula
<<~EOS
Some installed kegs have no formulae!
- This means they were either deleted or installed with `brew diy`.
+ This means they were either deleted or installed manually.
You should find replacements for the following formulae:
#{deleted_formulae.join("\n ")}
EOS | true |
Other | Homebrew | brew | c715ea7fd12271c1899d0335d30cb794bd3955b5.json | Document the `--quiet` flag on `brew update` | Library/Homebrew/cmd/update.sh | @@ -5,6 +5,7 @@
#: --merge Use `git merge` to apply updates (rather than `git rebase`).
#: --preinstall Run on auto-updates (e.g. before `brew install`). Skips some slower steps.
#: -f, --force Always do a slower, full update check (even if unnecessary).
+#: -q, --quiet Make some output more quiet
#: -v, --verbose Print the directories checked and `git` operations performed.
#: -d, --debug Display a trace of all shell commands as they are executed.
#: -h, --help Show this message. | true |
Other | Homebrew | brew | c715ea7fd12271c1899d0335d30cb794bd3955b5.json | Document the `--quiet` flag on `brew update` | Library/Homebrew/test/completions_spec.rb | @@ -200,6 +200,7 @@ def delete_completions_setting(setting: "linkcompletions")
"--help" => "Show this message.",
"--merge" => "Use `git merge` to apply updates (rather than `git rebase`).",
"--preinstall" => "Run on auto-updates (e.g. before `brew install`). Skips some slower steps.",
+ "--quiet" => "Make some output more quiet",
"--verbose" => "Print the directories checked and `git` operations performed.",
}
expect(described_class.command_options("update")).to eq expected_options
@@ -281,6 +282,7 @@ def delete_completions_setting(setting: "linkcompletions")
--help
--merge
--preinstall
+ --quiet
--verbose
"
return
@@ -345,6 +347,7 @@ def delete_completions_setting(setting: "linkcompletions")
'--help[Show this message]' \\
'--merge[Use `git merge` to apply updates (rather than `git rebase`)]' \\
'--preinstall[Run on auto-updates (e.g. before `brew install`). Skips some slower steps]' \\
+ '--quiet[Make some output more quiet]' \\
'--verbose[Print the directories checked and `git` operations performed]'
}
COMPLETION
@@ -404,6 +407,7 @@ def delete_completions_setting(setting: "linkcompletions")
__fish_brew_complete_arg 'update' -l help -d 'Show this message'
__fish_brew_complete_arg 'update' -l merge -d 'Use `git merge` to apply updates (rather than `git rebase`)'
__fish_brew_complete_arg 'update' -l preinstall -d 'Run on auto-updates (e.g. before `brew install`). Skips some slower steps'
+ __fish_brew_complete_arg 'update' -l quiet -d 'Make some output more quiet'
__fish_brew_complete_arg 'update' -l verbose -d 'Print the directories checked and `git` operations performed'
COMPLETION
end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `addressable` gem.
# Please instead update this file by running `bin/tapioca gem addressable`.
-# typed: true
-
module Addressable; end
module Addressable::IDNA | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `ast` gem.
# Please instead update this file by running `bin/tapioca gem ast`.
-# typed: true
-
module AST; end
class AST::Node | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/bindata@2.4.10.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `bindata` gem.
# Please instead update this file by running `bin/tapioca gem bindata`.
-# typed: true
-
module BinData
extend ::BinData::BitFieldFactory
extend ::BinData::IntFactory | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `byebug` gem.
# Please instead update this file by running `bin/tapioca gem byebug`.
-# typed: true
-
module Byebug
class << self
def attach; end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `coderay` gem.
# Please instead update this file by running `bin/tapioca gem coderay`.
-# typed: true
-
module CodeRay
class << self
def coderay_path(*path); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi | @@ -1,8 +1,10 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `commander` gem.
# Please instead update this file by running `bin/tapioca gem commander`.
-# typed: true
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
module Blank
class << self
@@ -253,14 +255,14 @@ end
Commander::VERSION = T.let(T.unsafe(nil), String)
class Object < ::BasicObject
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::ActiveSupport::ForkTracker::CoreExt
include ::ActiveSupport::ForkTracker::CoreExtPrivate
- include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::Kernel
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
- include ::ActiveSupport::Tryable
include ::ActiveSupport::Dependencies::Loadable
+ include ::ActiveSupport::Tryable
def get_binding; end
end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `connection_pool` gem.
# Please instead update this file by running `bin/tapioca gem connection_pool`.
-# typed: true
-
class ConnectionPool
def initialize(options = T.unsafe(nil), &block); end
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `docile` gem.
# Please instead update this file by running `bin/tapioca gem docile`.
-# typed: true
-
module Docile
extend ::Docile::Execution
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `domain_name` gem.
# Please instead update this file by running `bin/tapioca gem domain_name`.
-# typed: true
-
class DomainName
def initialize(hostname); end
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `elftools` gem.
# Please instead update this file by running `bin/tapioca gem elftools`.
-# typed: true
-
module ELFTools; end
module ELFTools::Constants | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `hana` gem.
# Please instead update this file by running `bin/tapioca gem hana`.
-# typed: true
-
module Hana; end
class Hana::Patch | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi | @@ -1,8 +1,10 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `highline` gem.
# Please instead update this file by running `bin/tapioca gem highline`.
-# typed: true
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
class HighLine
include ::HighLine::BuiltinStyles
@@ -838,14 +840,14 @@ module HighLine::Wrapper
end
class Object < ::BasicObject
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::ActiveSupport::ForkTracker::CoreExt
include ::ActiveSupport::ForkTracker::CoreExtPrivate
- include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::Kernel
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
- include ::ActiveSupport::Tryable
include ::ActiveSupport::Dependencies::Loadable
+ include ::ActiveSupport::Tryable
def or_ask(*args, &details); end
end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi | @@ -1,8 +1,10 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `hpricot` gem.
# Please instead update this file by running `bin/tapioca gem hpricot`.
-# typed: true
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
module Hpricot
class << self
@@ -628,14 +630,14 @@ module Hpricot::XMLDecl::Trav
end
class Object < ::BasicObject
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::ActiveSupport::ForkTracker::CoreExt
include ::ActiveSupport::ForkTracker::CoreExtPrivate
- include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::Kernel
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
- include ::ActiveSupport::Tryable
include ::ActiveSupport::Dependencies::Loadable
+ include ::ActiveSupport::Tryable
private
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.4.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `http-cookie` gem.
# Please instead update this file by running `bin/tapioca gem http-cookie`.
-# typed: true
-
module HTTP; end
class HTTP::Cookie | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `method_source` gem.
# Please instead update this file by running `bin/tapioca gem method_source`.
-# typed: true
-
module MethodSource
extend ::MethodSource::CodeHelpers
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `mustache` gem.
# Please instead update this file by running `bin/tapioca gem mustache`.
-# typed: true
-
class Mustache
def initialize(options = T.unsafe(nil)); end
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi | @@ -1,8 +1,8 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `net-http-digest_auth` gem.
# Please instead update this file by running `bin/tapioca gem net-http-digest_auth`.
-# typed: true
-
# THIS IS AN EMPTY RBI FILE.
# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `net-http-persistent` gem.
# Please instead update this file by running `bin/tapioca gem net-http-persistent`.
-# typed: true
-
class Net::HTTP::Persistent
def initialize(name: T.unsafe(nil), proxy: T.unsafe(nil), pool_size: T.unsafe(nil)); end
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `patchelf` gem.
# Please instead update this file by running `bin/tapioca gem patchelf`.
-# typed: true
-
module PatchELF; end
module PatchELF::Helper | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `plist` gem.
# Please instead update this file by running `bin/tapioca gem plist`.
-# typed: true
-
module Plist
class << self
def parse_xml(filename_or_xml); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi | @@ -1,22 +1,24 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `pry` gem.
# Please instead update this file by running `bin/tapioca gem pry`.
-# typed: true
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
class BasicObject
def __binding__; end
end
class Object < ::BasicObject
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::ActiveSupport::ForkTracker::CoreExt
include ::ActiveSupport::ForkTracker::CoreExtPrivate
- include ::ActiveSupport::ToJsonWithActiveSupportEncoder
include ::Kernel
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
- include ::ActiveSupport::Tryable
include ::ActiveSupport::Dependencies::Loadable
+ include ::ActiveSupport::Tryable
def __binding__; end
def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/racc@1.6.0.rbi | @@ -1,13 +1,20 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `racc` gem.
# Please instead update this file by running `bin/tapioca gem racc`.
-# typed: true
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
class Object < ::BasicObject
+ include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+ include ::ActiveSupport::ForkTracker::CoreExt
+ include ::ActiveSupport::ForkTracker::CoreExtPrivate
include ::Kernel
include ::JSON::Ext::Generator::GeneratorMethods::Object
include ::PP::ObjectMixin
+ include ::ActiveSupport::Dependencies::Loadable
+ include ::ActiveSupport::Tryable
end
ParseError = Racc::ParseError | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rack` gem.
# Please instead update this file by running `bin/tapioca gem rack`.
-# typed: true
-
module Rack
class << self
def release; end
@@ -934,7 +934,11 @@ class Rack::Request
def delete_param(k); end
def params; end
+ def query; end
def update_param(k, v); end
+ def version_supplied; end
+ def version_supplied=(_arg0); end
+ def xhr?; end
class << self
def ip_filter; end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rbi@0.0.14.rbi | @@ -1842,8 +1842,17 @@ class RBI::Tree < ::RBI::NodeWithComments
sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void }
def create_path(constant, &block); end
- sig { params(name: ::String, value: ::String).void }
- def create_type_member(name, value: T.unsafe(nil)); end
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).void
+ end
+ def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
sig { params(annotation: ::String).void }
def deannotate!(annotation); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rdiscount` gem.
# Please instead update this file by running `bin/tapioca gem rdiscount`.
-# typed: true
-
Markdown = RDiscount
class RDiscount | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rexml` gem.
# Please instead update this file by running `bin/tapioca gem rexml`.
-# typed: true
-
class REXML::AttlistDecl < ::REXML::Child
include ::Enumerable
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `ronn` gem.
# Please instead update this file by running `bin/tapioca gem ronn`.
-# typed: true
-
module Ronn
class << self
def new(filename, attributes = T.unsafe(nil), &block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rspec-github` gem.
# Please instead update this file by running `bin/tapioca gem rspec-github`.
-# typed: true
-
module RSpec
extend ::RSpec::Support::Warnings
extend ::RSpec::Core::Warnings
@@ -17,6 +17,8 @@ module RSpec
def context(*args, &example_group_block); end
def current_example; end
def current_example=(example); end
+ def current_scope; end
+ def current_scope=(scope); end
def describe(*args, &example_group_block); end
def example_group(*args, &example_group_block); end
def fcontext(*args, &example_group_block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rspec-its` gem.
# Please instead update this file by running `bin/tapioca gem rspec-its`.
-# typed: true
-
module RSpec
extend ::RSpec::Support::Warnings
extend ::RSpec::Core::Warnings
@@ -17,6 +17,8 @@ module RSpec
def context(*args, &example_group_block); end
def current_example; end
def current_example=(example); end
+ def current_scope; end
+ def current_scope=(scope); end
def describe(*args, &example_group_block); end
def example_group(*args, &example_group_block); end
def fcontext(*args, &example_group_block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rspec-retry` gem.
# Please instead update this file by running `bin/tapioca gem rspec-retry`.
-# typed: true
-
module RSpec
extend ::RSpec::Support::Warnings
extend ::RSpec::Core::Warnings
@@ -17,6 +17,8 @@ module RSpec
def context(*args, &example_group_block); end
def current_example; end
def current_example=(example); end
+ def current_scope; end
+ def current_scope=(scope); end
def describe(*args, &example_group_block); end
def example_group(*args, &example_group_block); end
def fcontext(*args, &example_group_block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.3.rbi | @@ -17,6 +17,8 @@ module RSpec
def context(*args, &example_group_block); end
def current_example; end
def current_example=(example); end
+ def current_scope; end
+ def current_scope=(scope); end
def describe(*args, &example_group_block); end
def example_group(*args, &example_group_block); end
def fcontext(*args, &example_group_block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rspec-wait` gem.
# Please instead update this file by running `bin/tapioca gem rspec-wait`.
-# typed: true
-
module RSpec
extend ::RSpec::Support::Warnings
extend ::RSpec::Core::Warnings
@@ -17,6 +17,8 @@ module RSpec
def context(*args, &example_group_block); end
def current_example; end
def current_example=(example); end
+ def current_scope; end
+ def current_scope=(scope); end
def describe(*args, &example_group_block); end
def example_group(*args, &example_group_block); end
def fcontext(*args, &example_group_block); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rubocop@1.27.0.rbi | @@ -2693,10 +2693,6 @@ class RuboCop::Cop::Layout::ExtraSpacing < ::RuboCop::Cop::Base
def force_equal_sign_alignment?; end
def ignored_range?(ast, start_pos); end
def ignored_ranges(ast); end
-
- class << self
- def autocorrect_incompatible_with; end
- end
end
RuboCop::Cop::Layout::ExtraSpacing::MSG_UNALIGNED_ASGN = T.let(T.unsafe(nil), String)
@@ -9706,6 +9702,7 @@ end
RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String)
class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
+ include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue
include ::RuboCop::Cop::FrozenStringLiteral
include ::RuboCop::Cop::ConfigurableEnforcedStyle
@@ -9715,6 +9712,7 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end
def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end
def splat_value(param0 = T.unsafe(nil)); end
+ def t_let(param0 = T.unsafe(nil)); end
private
@@ -9724,7 +9722,6 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base
def frozen_regexp_or_range_literals?(node); end
def immutable_literal?(node); end
def mutable_literal?(value); end
- def on_assignment(value); end
def requires_parentheses?(node); end
def shareable_constant_value?(node); end
def strict_check(value); end
@@ -11703,10 +11700,6 @@ class RuboCop::Cop::Style::TrailingCommaInArguments < ::RuboCop::Cop::Base
def on_csend(node); end
def on_send(node); end
-
- class << self
- def autocorrect_incompatible_with; end
- end
end
class RuboCop::Cop::Style::TrailingCommaInArrayLiteral < ::RuboCop::Cop::Base
@@ -12991,8 +12984,8 @@ end
RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String)
-RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter)
-RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter)
+RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter)
+RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter)
class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
include ::RuboCop::Formatter::TextUtil | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `ruby-progressbar` gem.
# Please instead update this file by running `bin/tapioca gem ruby-progressbar`.
-# typed: true
-
class ProgressBar
class << self
def create(*args); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/rubyntlm@0.6.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rubyntlm` gem.
# Please instead update this file by running `bin/tapioca gem rubyntlm`.
-# typed: true
-
module Net::NTLM
class << self
def apply_des(plain, keys); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `simplecov-html` gem.
# Please instead update this file by running `bin/tapioca gem simplecov-html`.
-# typed: true
-
module SimpleCov
extend ::SimpleCov::Configuration
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `simplecov` gem.
# Please instead update this file by running `bin/tapioca gem simplecov`.
-# typed: true
-
module SimpleCov
extend ::SimpleCov::Configuration
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi | @@ -1,8 +1,8 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `sorbet-runtime-stub` gem.
# Please instead update this file by running `bin/tapioca gem sorbet-runtime-stub`.
-# typed: true
-
# THIS IS AN EMPTY RBI FILE.
# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi | @@ -592,7 +592,7 @@ class Tapioca::Dsl::Compiler
abstract!
- ConstantType = type_member(upper: Module)
+ ConstantType = type_member { { upper: Module } }
sig { params(pipeline: ::Tapioca::Dsl::Pipeline, root: ::RBI::Tree, constant: ConstantType).void }
def initialize(pipeline, root, constant); end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `tzinfo` gem.
# Please instead update this file by running `bin/tapioca gem tzinfo`.
-# typed: true
-
module TZInfo; end
class TZInfo::AbsoluteDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `unf` gem.
# Please instead update this file by running `bin/tapioca gem unf`.
-# typed: true
-
module UNF; end
class UNF::Normalizer | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.1.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `unicode-display_width` gem.
# Please instead update this file by running `bin/tapioca gem unicode-display_width`.
-# typed: true
-
module Unicode; end
class Unicode::DisplayWidth | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `uri_template` gem.
# Please instead update this file by running `bin/tapioca gem uri_template`.
-# typed: true
-
module URITemplate
extend ::URITemplate::ClassMethods
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/warning@1.2.1.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `warning` gem.
# Please instead update this file by running `bin/tapioca gem warning`.
-# typed: true
-
module Warning
extend ::Warning
extend ::Warning::Processor | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi | @@ -1,9 +1,9 @@
+# typed: true
+
# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `webrick` gem.
# Please instead update this file by running `bin/tapioca gem webrick`.
-# typed: true
-
module WEBrick::AccessLog
private
| true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi | @@ -8,10 +8,10 @@ module YARDSorbet; end
module YARDSorbet::Directives
class << self
- sig { params(docstring: String, directives: T::Array[String]).void }
+ sig { params(docstring: ::String, directives: T::Array[::String]).void }
def add_directives(docstring, directives); end
- sig { params(docstring: T.nilable(String)).returns([YARD::Docstring, T::Array[String]]) }
+ sig { params(docstring: T.nilable(::String)).returns([::YARD::Docstring, T::Array[::String]]) }
def extract_directives(docstring); end
end
end
@@ -32,7 +32,7 @@ class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base
private
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
def const_assign_node?(node); end
end
@@ -42,7 +42,7 @@ class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base
private
- sig { returns(YARD::CodeObjects::NamespaceObject) }
+ sig { returns(::YARD::CodeObjects::NamespaceObject) }
def included_in; end
end
@@ -51,7 +51,7 @@ class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby:
def process; end
class << self
- sig { params(code_obj: String).returns(T.nilable(String)) }
+ sig { params(code_obj: ::String).returns(T.nilable(::String)) }
def mixed_in_class_methods(code_obj); end
end
end
@@ -62,13 +62,19 @@ class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base
private
- sig { params(method_node: YARD::Parser::Ruby::AstNode, node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+ sig do
+ params(
+ method_node: ::YARD::Parser::Ruby::AstNode,
+ node: ::YARD::Parser::Ruby::AstNode,
+ docstring: ::YARD::Docstring
+ ).void
+ end
def parse_params(method_node, node, docstring); end
- sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
def parse_return(node, docstring); end
- sig { params(method_node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+ sig { params(method_node: ::YARD::Parser::Ruby::AstNode, docstring: ::YARD::Docstring).void }
def parse_sig(method_node, docstring); end
end
@@ -80,13 +86,20 @@ module YARDSorbet::Handlers::StructClassHandler
private
- sig { params(object: YARD::CodeObjects::MethodObject, props: T::Array[YARDSorbet::TStructProp], docstring: YARD::Docstring, directives: T::Array[String]).void }
+ sig do
+ params(
+ object: ::YARD::CodeObjects::MethodObject,
+ props: T::Array[::YARDSorbet::TStructProp],
+ docstring: ::YARD::Docstring,
+ directives: T::Array[::String]
+ ).void
+ end
def decorate_t_struct_init(object, props, docstring, directives); end
- sig { params(props: T::Array[YARDSorbet::TStructProp], class_ns: YARD::CodeObjects::ClassObject).void }
+ sig { params(props: T::Array[::YARDSorbet::TStructProp], class_ns: ::YARD::CodeObjects::ClassObject).void }
def process_t_struct_props(props, class_ns); end
- sig { params(props: T::Array[YARDSorbet::TStructProp]).returns(T::Array[[String, T.nilable(String)]]) }
+ sig { params(props: T::Array[::YARDSorbet::TStructProp]).returns(T::Array[[::String, T.nilable(::String)]]) }
def to_object_parameters(props); end
end
@@ -96,90 +109,99 @@ class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base
private
- sig { params(object: YARD::CodeObjects::MethodObject, prop: YARDSorbet::TStructProp).void }
+ sig { params(object: ::YARD::CodeObjects::MethodObject, prop: ::YARDSorbet::TStructProp).void }
def decorate_object(object, prop); end
- sig { returns(T.nilable(String)) }
+ sig { returns(T.nilable(::String)) }
def default_value; end
- sig { params(name: String).returns(YARDSorbet::TStructProp) }
+ sig { params(name: ::String).returns(::YARDSorbet::TStructProp) }
def make_prop(name); end
- sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
+ sig { params(object: ::YARD::CodeObjects::MethodObject, name: ::String).void }
def register_attrs(object, name); end
- sig { params(prop: YARDSorbet::TStructProp).void }
+ sig { params(prop: ::YARDSorbet::TStructProp).void }
def update_state(prop); end
end
module YARDSorbet::NodeUtils
class << self
- sig { params(node: YARD::Parser::Ruby::AstNode, _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void).void }
+ sig do
+ params(
+ node: ::YARD::Parser::Ruby::AstNode,
+ _blk: T.proc.params(n: ::YARD::Parser::Ruby::AstNode).void
+ ).void
+ end
def bfs_traverse(node, &_blk); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode)) }
+ sig do
+ params(
+ node: ::YARD::Parser::Ruby::AstNode
+ ).returns(T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode))
+ end
def get_method_node(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(YARD::Parser::Ruby::AstNode) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::YARD::Parser::Ruby::AstNode) }
def sibling_node(node); end
end
end
YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array)
-YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode) }
+YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(::YARD::Parser::Ruby::MethodCallNode, ::YARD::Parser::Ruby::MethodDefinitionNode) }
YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array)
module YARDSorbet::SigToYARD
class << self
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert(node); end
private
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(::String) }
def build_generic_type(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_aref(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_array(node); end
- sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
def convert_call(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_collection(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_hash(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_list(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_node(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_node_type(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_ref(node); end
- sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::MethodCallNode).returns(T::Array[::String]) }
def convert_t_method(node); end
- sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+ sig { params(node: ::YARD::Parser::Ruby::AstNode).returns(T::Array[::String]) }
def convert_unknown(node); end
end
end
class YARDSorbet::TStructProp < ::T::Struct
- const :default, T.nilable(String)
- const :doc, String
- const :prop_name, String
- const :source, String
- const :types, T::Array[String]
+ const :default, T.nilable(::String)
+ const :doc, ::String
+ const :prop_name, ::String
+ const :source, ::String
+ const :types, T::Array[::String]
class << self
def inherited(s); end
@@ -188,10 +210,24 @@ end
module YARDSorbet::TagUtils
class << self
- sig { params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String)).returns(T.nilable(YARD::Tags::Tag)) }
+ sig do
+ params(
+ docstring: ::YARD::Docstring,
+ tag_name: ::String,
+ name: T.nilable(::String)
+ ).returns(T.nilable(::YARD::Tags::Tag))
+ end
def find_tag(docstring, tag_name, name); end
- sig { params(docstring: YARD::Docstring, tag_name: String, types: T.nilable(T::Array[String]), name: T.nilable(String), text: String).void }
+ sig do
+ params(
+ docstring: ::YARD::Docstring,
+ tag_name: ::String,
+ types: T.nilable(T::Array[::String]),
+ name: T.nilable(::String),
+ text: ::String
+ ).void
+ end
def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end
end
end | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/gems/yard@0.9.27.rbi | @@ -79,6 +79,37 @@ end
Gem::USE_BUNDLER_FOR_GEMDEPS = T.let(T.unsafe(nil), TrueClass)
Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
+class IRB::SLex
+ def initialize; end
+
+ def create(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+ def def_rule(token, preproc = T.unsafe(nil), postproc = T.unsafe(nil), &block); end
+ def def_rules(*tokens, &block); end
+ def inspect; end
+ def match(token); end
+ def postproc(token); end
+ def preproc(token, proc); end
+ def search(token); end
+end
+
+IRB::SLex::DOUT = T.let(T.unsafe(nil), IRB::Notifier::CompositeNotifier)
+IRB::SLex::D_DEBUG = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+IRB::SLex::D_DETAIL = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+IRB::SLex::D_WARN = T.let(T.unsafe(nil), IRB::Notifier::LeveledNotifier)
+
+class IRB::SLex::Node
+ def initialize(preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+
+ def create_subnode(chrs, preproc = T.unsafe(nil), postproc = T.unsafe(nil)); end
+ def match(chrs, op = T.unsafe(nil)); end
+ def match_io(io, op = T.unsafe(nil)); end
+ def postproc; end
+ def postproc=(_arg0); end
+ def preproc; end
+ def preproc=(_arg0); end
+ def search(chrs, opt = T.unsafe(nil)); end
+end
+
class Insertion
def initialize(list, value); end
@@ -93,11 +124,39 @@ class Insertion
end
class Module
+ include ::ActiveSupport::Dependencies::ModuleConstMissing
+
def class_name; end
end
+Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
+Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
+Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
RUBY19 = T.let(T.unsafe(nil), TrueClass)
+class Rack::Request
+ include ::Rack::Request::Env
+ include ::Rack::Request::Helpers
+
+ def initialize(env); end
+
+ def delete_param(k); end
+ def params; end
+ def query; end
+ def update_param(k, v); end
+ def version_supplied; end
+ def version_supplied=(_arg0); end
+ def xhr?; end
+
+ class << self
+ def ip_filter; end
+ def ip_filter=(_arg0); end
+ end
+end
+
+Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array)
+Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array)
+
class String
include ::Comparable
include ::JSON::Ext::Generator::GeneratorMethods::String
@@ -127,6 +186,14 @@ class SymbolHash < ::Hash
end
end
+class WEBrick::HTTPRequest
+ def version_supplied; end
+ def version_supplied=(_arg0); end
+ def xhr?; end
+end
+
+WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer)
+
module YARD
class << self
def load_plugins; end
@@ -504,7 +571,11 @@ end
YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String)
YARD::CONFIG_DIR = T.let(T.unsafe(nil), String)
-module YARD::CodeObjects; end
+
+module YARD::CodeObjects
+ extend ::YARD::CodeObjects::NamespaceMapper
+end
+
YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array)
YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array)
YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array) | true |
Other | Homebrew | brew | bb38f4bd5f0a1fdbb7b097cb06701b24bfd3f0bf.json | Renegerate all RBI files for new Sorbet | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -2938,24 +2938,6 @@ class IRB::SLex
def Fail(err=T.unsafe(nil), *rest); end
def Raise(err=T.unsafe(nil), *rest); end
-
- def create(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end
-
- def def_rule(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil), &block); end
-
- def def_rules(*tokens, &block); end
-
- def match(token); end
-
- def postproc(token); end
-
- def preproc(token, proc); end
-
- def search(token); end
- DOUT = ::T.let(nil, ::T.untyped)
- D_DEBUG = ::T.let(nil, ::T.untyped)
- D_DETAIL = ::T.let(nil, ::T.untyped)
- D_WARN = ::T.let(nil, ::T.untyped)
end
class IRB::SLex::ErrNodeAlreadyExists
@@ -2970,29 +2952,6 @@ end
class IRB::SLex::ErrNodeNothing
end
-class IRB::SLex::Node
- def create_subnode(chrs, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end
-
- def initialize(preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end
-
- def match(chrs, op=T.unsafe(nil)); end
-
- def match_io(io, op=T.unsafe(nil)); end
-
- def postproc(); end
-
- def postproc=(postproc); end
-
- def preproc(); end
-
- def preproc=(preproc); end
-
- def search(chrs, opt=T.unsafe(nil)); end
-end
-
-class IRB::SLex::Node
-end
-
class IRB::SLex
extend ::Exception2MessageMapper
def self.included(mod); end
@@ -4338,14 +4297,6 @@ end
class Racc::CparseParams
end
-class Rack::Request
- def query(); end
-
- def version_supplied(); end
-
- def version_supplied=(version_supplied); end
-end
-
class Random
def self.bytes(arg); end
end
@@ -5247,11 +5198,6 @@ class RuboCop::Cop::FormulaCop
def required_dependency_name?(param0, param1); end
end
-class RuboCop::Cop::Style::MutableConstant
- include ::RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
- def t_let(param0=T.unsafe(nil)); end
-end
-
module RuboCop::RSpec::ExpectOffense
def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end
@@ -7212,14 +7158,6 @@ class Version
extend ::T::Private::Methods::SingletonMethodHooks
end
-class WEBrick::HTTPRequest
- def version_supplied(); end
-
- def version_supplied=(version_supplied); end
-
- def xhr?(); end
-end
-
class WeakRef
def initialize(orig); end
end
@@ -7431,10 +7369,6 @@ end
module Webrobots
end
-module YARD::CodeObjects
- extend ::YARD::CodeObjects::NamespaceMapper
-end
-
module YARDSorbet::Directives
extend ::T::Sig
extend ::T::Private::Methods::MethodHooks | true |
Other | Homebrew | brew | 48bf0cc7ad6acc119e75072b170a0b0ca4a5de9a.json | Update RBI files for parlour. | Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi | @@ -1,1614 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `parlour` gem.
-# Please instead update this file by running `bin/tapioca gem parlour`.
-
-# typed: true
-
-module Kernel
- extend ::Forwardable
-end
-
-module Parlour; end
-
-class Parlour::ConflictResolver
- sig { params(namespace: Parlour::RbiGenerator::Namespace, resolver: T.proc.params(desc: String, choices: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T.nilable(Parlour::RbiGenerator::RbiObject))).void }
- def resolve_conflicts(namespace, &resolver); end
-
- private
-
- sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) }
- def all_eql?(arr); end
-
- sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(String)).void }
- def deduplicate_mixins_of_name(namespace, name); end
-
- sig { params(arr: T::Array[T.untyped]).returns(T.nilable(Symbol)) }
- def merge_strategy(arr); end
-end
-
-module Parlour::Conversion; end
-
-class Parlour::Conversion::Converter
- abstract!
-
- def initialize; end
-
- sig { params(msg: String, node: Parlour::RbiGenerator::RbiObject).void }
- def add_warning(msg, node); end
-
- sig { returns(T::Array[[String, Parlour::TypedObject]]) }
- def warnings; end
-end
-
-class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter
- sig { params(rbs_gen: Parlour::RbsGenerator).void }
- def initialize(rbs_gen); end
-
- sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void }
- def convert_all(from, to); end
-
- sig { params(node: Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void }
- def convert_object(node, new_parent); end
-
- sig { returns(Parlour::RbsGenerator) }
- def rbs_gen; end
-end
-
-module Parlour::Debugging
- class << self
- sig { params(value: T::Boolean).returns(T::Boolean) }
- def debug_mode=(value); end
-
- sig { returns(T::Boolean) }
- def debug_mode?; end
-
- sig { params(object: T.untyped, message: String).void }
- def debug_puts(object, message); end
-
- sig { params(object: T.untyped).returns(String) }
- def name_for_debug_caller(object); end
- end
-end
-
-module Parlour::Debugging::Tree
- class << self
- sig { params(message: String).returns(String) }
- def begin(message); end
-
- sig { params(message: String).returns(String) }
- def end(message); end
-
- sig { params(message: String).returns(String) }
- def here(message); end
-
- def line_prefix; end
- def text_prefix; end
- end
-end
-
-Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer)
-
-class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator
- sig { override.returns(T.nilable(Parlour::Plugin)) }
- def current_plugin; end
-
- sig { returns(T.untyped) }
- def detached!; end
-
- sig { override.returns(Parlour::Options) }
- def options; end
-
- sig { override.params(strictness: String).returns(String) }
- def rbi(strictness = T.unsafe(nil)); end
-end
-
-class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator
- sig { override.returns(T.nilable(Parlour::Plugin)) }
- def current_plugin; end
-
- sig { returns(T.untyped) }
- def detached!; end
-
- sig { override.returns(Parlour::Options) }
- def options; end
-
- sig { override.returns(String) }
- def rbs; end
-end
-
-class Parlour::Generator
- sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
- def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end
-
- sig { overridable.returns(T.nilable(Parlour::Plugin)) }
- def current_plugin; end
-
- def current_plugin=(_arg0); end
-
- sig { overridable.returns(Parlour::Options) }
- def options; end
-end
-
-class Parlour::Options
- sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
- def initialize(break_params:, tab_size:, sort_namespaces:); end
-
- sig { returns(Integer) }
- def break_params; end
-
- sig { params(level: Integer, str: String).returns(String) }
- def indented(level, str); end
-
- sig { returns(T::Boolean) }
- def sort_namespaces; end
-
- sig { returns(Integer) }
- def tab_size; end
-end
-
-class Parlour::ParseError < ::StandardError
- def initialize(buffer, range); end
-
- sig { returns(Parser::Source::Buffer) }
- def buffer; end
-
- sig { returns(Parser::Source::Range) }
- def range; end
-end
-
-class Parlour::Plugin
- abstract!
-
- sig { params(options: T::Hash[T.untyped, T.untyped]).void }
- def initialize(options); end
-
- sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void }
- def generate(root); end
-
- sig { returns(T.nilable(String)) }
- def strictness; end
-
- def strictness=(_arg0); end
-
- class << self
- sig { params(new_plugin: T.class_of(Parlour::Plugin)).void }
- def inherited(new_plugin); end
-
- sig { returns(T::Hash[String, T.class_of(Parlour::Plugin)]) }
- def registered_plugins; end
-
- sig { params(plugins: T::Array[Parlour::Plugin], generator: Parlour::RbiGenerator, allow_failure: T::Boolean).void }
- def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end
- end
-end
-
-class Parlour::RbiGenerator < ::Parlour::Generator
- def initialize(**hash); end
-
- sig { overridable.params(strictness: String).returns(String) }
- def rbi(strictness = T.unsafe(nil)); end
-
- sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
- def root; end
-end
-
-class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Arbitrary).void)).void }
- def initialize(generator, code: T.unsafe(nil), &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(String) }
- def code; end
-
- def code=(_arg0); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
- sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).void }
- def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end
-
- sig { override.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T::Boolean) }
- def class_attribute; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { returns(Symbol) }
- def kind; end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-
- private
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_definition(indent_level, options); end
-end
-
-class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
- sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
- def initialize(generator, name, final, sealed, superclass, abstract, &block); end
-
- sig { returns(T::Boolean) }
- def abstract; end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.nilable(String)) }
- def superclass; end
-end
-
-class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: String, value: T.any(Parlour::Types::Type, String), eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).void }
- def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- def eigen_constant; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def value; end
-end
-
-class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
- sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, enums: T::Array[T.any(String, [String, String])], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).void }
- def initialize(generator, name, final, sealed, enums, abstract, &block); end
-
- sig { returns(T::Array[T.any(String, [String, String])]) }
- def enums; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_body(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).void }
- def initialize(generator, name: T.unsafe(nil), &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).void }
- def initialize(generator, name: T.unsafe(nil), &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: String, parameters: T::Array[Parlour::RbiGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).void }
- def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
- sig { overridable.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T::Boolean) }
- def abstract; end
-
- sig { returns(T::Boolean) }
- def class_method; end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { returns(T::Boolean) }
- def final; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { returns(T::Boolean) }
- def implementation; end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T::Boolean) }
- def overridable; end
-
- sig { returns(T::Boolean) }
- def override; end
-
- sig { returns(T::Array[Parlour::RbiGenerator::Parameter]) }
- def parameters; end
-
- sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
- def return_type; end
-
- sig { returns(T::Array[Symbol]) }
- def type_parameters; end
-
- private
-
- sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_definition(indent_level, options); end
-
- sig { returns(String) }
- def qualifiers; end
-end
-
-class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace
- sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
- def initialize(generator, name, final, sealed, interface, abstract, &block); end
-
- sig { returns(T::Boolean) }
- def abstract; end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { returns(T::Boolean) }
- def interface; end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: T.nilable(String), final: T::Boolean, sealed: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)).void }
- def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end
-
- sig { params(comment: T.any(String, T::Array[String])).void }
- def add_comment_to_next_child(comment); end
-
- sig { returns(T::Array[Parlour::RbiGenerator::TypeAlias]) }
- def aliases; end
-
- sig { returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
- def children; end
-
- sig { returns(T::Array[Parlour::RbiGenerator::Constant]) }
- def constants; end
-
- def create_arbitrary(code:, &block); end
- def create_attr(*args, &blk); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
- def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
- def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
- def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
-
- sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
- def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
-
- sig { params(name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ClassNamespace) }
- def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
- sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).returns(Parlour::RbiGenerator::Constant) }
- def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
-
- sig { params(name: String, final: T::Boolean, sealed: T::Boolean, enums: T.nilable(T::Array[T.any(String, [String, String])]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).returns(Parlour::RbiGenerator::EnumClassNamespace) }
- def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
- sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).returns(Parlour::RbiGenerator::Extend) }
- def create_extend(name, &block); end
-
- sig { params(extendables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Extend]) }
- def create_extends(extendables); end
-
- sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).returns(Parlour::RbiGenerator::Include) }
- def create_include(name, &block); end
-
- sig { params(includables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Include]) }
- def create_includes(includables); end
-
- sig { params(name: String, parameters: T.nilable(T::Array[Parlour::RbiGenerator::Parameter]), return_type: T.nilable(T.any(Parlour::Types::Type, String)), returns: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).returns(Parlour::RbiGenerator::Method) }
- def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
- sig { params(name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ModuleNamespace) }
- def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
- sig { params(name: String, final: T::Boolean, sealed: T::Boolean, props: T.nilable(T::Array[Parlour::RbiGenerator::StructProp]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).returns(Parlour::RbiGenerator::StructClassNamespace) }
- def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).returns(Parlour::RbiGenerator::TypeAlias) }
- def create_type_alias(name, type:, &block); end
-
- sig { override.overridable.returns(String) }
- def describe; end
-
- sig { returns(T::Array[Parlour::RbiGenerator::Extend]) }
- def extends; end
-
- sig { returns(T::Boolean) }
- def final; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { returns(T::Array[Parlour::RbiGenerator::Include]) }
- def includes; end
-
- sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { params(constant: Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
- def path(constant, &block); end
-
- sig { returns(T::Boolean) }
- def sealed; end
-
- def type_aliases(*args, &blk); end
-
- private
-
- sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_body(indent_level, options); end
-
- sig { params(object: Parlour::RbiGenerator::RbiObject).void }
- def move_next_comments(object); end
-end
-
-Parlour::RbiGenerator::Options = Parlour::Options
-
-class Parlour::RbiGenerator::Parameter
- sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), default: T.nilable(String)).void }
- def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T.nilable(String)) }
- def default; end
-
- sig { void }
- def generalize_from_rbi!; end
-
- sig { returns(Symbol) }
- def kind; end
-
- sig { returns(String) }
- def name; end
-
- sig { returns(String) }
- def name_without_kind; end
-
- sig { returns(String) }
- def to_def_param; end
-
- sig { returns(String) }
- def to_sig_param; end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-
-class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
- abstract!
-
- sig { params(generator: Parlour::Generator, name: String).void }
- def initialize(generator, name); end
-
- sig { override.overridable.returns(String) }
- def describe; end
-
- sig { abstract.void }
- def generalize_from_rbi!; end
-
- sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { returns(Parlour::Generator) }
- def generator; end
-
- sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
- sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, props: T::Array[Parlour::RbiGenerator::StructProp], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).void }
- def initialize(generator, name, final, sealed, props, abstract, &block); end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_body(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T::Array[Parlour::RbiGenerator::StructProp]) }
- def props; end
-end
-
-class Parlour::RbiGenerator::StructProp
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), optional: T.nilable(T.any(Symbol, T::Boolean)), enum: T.nilable(String), dont_store: T.nilable(T::Boolean), foreign: T.nilable(String), default: T.nilable(String), factory: T.nilable(String), immutable: T.nilable(T::Boolean), array: T.nilable(String), override: T.nilable(T::Boolean), redaction: T.nilable(String)).void }
- def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T.nilable(String)) }
- def array; end
-
- sig { returns(T.nilable(String)) }
- def default; end
-
- sig { returns(T.nilable(T::Boolean)) }
- def dont_store; end
-
- sig { returns(T.nilable(String)) }
- def enum; end
-
- sig { returns(T.nilable(String)) }
- def factory; end
-
- sig { returns(T.nilable(String)) }
- def foreign; end
-
- sig { void }
- def generalize_from_rbi!; end
-
- sig { returns(T.nilable(T::Boolean)) }
- def immutable; end
-
- sig { returns(String) }
- def name; end
-
- sig { returns(T.nilable(T.any(Symbol, T::Boolean))) }
- def optional; end
-
- sig { returns(T.nilable(T::Boolean)) }
- def override; end
-
- sig { returns(T.nilable(String)) }
- def redaction; end
-
- sig { returns(String) }
- def to_prop_call; end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array)
-
-class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
- sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).void }
- def initialize(generator, name:, type:, &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.void }
- def generalize_from_rbi!; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbi(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-class Parlour::RbsGenerator < ::Parlour::Generator
- def initialize(**hash); end
-
- sig { overridable.returns(String) }
- def rbs; end
-
- sig { overridable.returns(Parlour::RbsGenerator::Namespace) }
- def root; end
-end
-
-class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Arbitrary).void)).void }
- def initialize(generator, code: T.unsafe(nil), &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(String) }
- def code; end
-
- def code=(_arg0); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method
- sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).void }
- def initialize(generator, name, kind, type, &block); end
-
- sig { override.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { returns(Symbol) }
- def kind; end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-class Parlour::RbsGenerator::Block
- sig { params(type: Parlour::Types::Proc, required: T::Boolean).void }
- def initialize(type, required); end
-
- sig { overridable.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { params(options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(options); end
-
- sig { returns(T::Boolean) }
- def required; end
-
- sig { returns(Parlour::Types::Proc) }
- def type; end
-end
-
-class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace
- sig { params(generator: Parlour::Generator, name: String, superclass: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)).void }
- def initialize(generator, name, superclass, &block); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
- def superclass; end
-end
-
-class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Constant).void)).void }
- def initialize(generator, name, type:, &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Extend).void)).void }
- def initialize(generator, type:, &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Include).void)).void }
- def initialize(generator, type:, &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-end
-
-class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, name: String, signatures: T::Array[Parlour::RbsGenerator::MethodSignature], class_method: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Method).void)).void }
- def initialize(generator, name, signatures, class_method: T.unsafe(nil), &block); end
-
- sig { overridable.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T::Boolean) }
- def class_method; end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T::Array[Parlour::RbsGenerator::MethodSignature]) }
- def signatures; end
-end
-
-class Parlour::RbsGenerator::MethodSignature
- sig { params(parameters: T::Array[Parlour::RbsGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(Parlour::RbsGenerator::Block), type_parameters: T.nilable(T::Array[Symbol])).void }
- def initialize(parameters, return_type = T.unsafe(nil), block: T.unsafe(nil), type_parameters: T.unsafe(nil)); end
-
- sig { overridable.params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T.nilable(Parlour::RbsGenerator::Block)) }
- def block; end
-
- sig { params(options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(options); end
-
- sig { returns(T::Array[Parlour::RbsGenerator::Parameter]) }
- def parameters; end
-
- sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
- def return_type; end
-
- sig { returns(T::Array[Symbol]) }
- def type_parameters; end
-end
-
-class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-end
-
-class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, name: T.nilable(String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).void }
- def initialize(generator, name = T.unsafe(nil), &block); end
-
- sig { params(comment: T.any(String, T::Array[String])).void }
- def add_comment_to_next_child(comment); end
-
- sig { returns(T::Array[Parlour::RbsGenerator::TypeAlias]) }
- def aliases; end
-
- sig { returns(T::Array[Parlour::RbsGenerator::RbsObject]) }
- def children; end
-
- sig { returns(T::Array[Parlour::RbsGenerator::Constant]) }
- def constants; end
-
- def create_arbitrary(code:, &block); end
- def create_attr(*args, &blk); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
- def create_attr_accessor(name, type:, &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
- def create_attr_reader(name, type:, &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
- def create_attr_writer(name, type:, &block); end
-
- sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Attribute).void)).returns(Parlour::RbsGenerator::Attribute) }
- def create_attribute(name, kind:, type:, &block); end
-
- sig { params(name: String, superclass: T.nilable(T.any(Parlour::Types::Type, String)), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)).returns(Parlour::RbsGenerator::ClassNamespace) }
- def create_class(name, superclass: T.unsafe(nil), &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Constant).void)).returns(Parlour::RbsGenerator::Constant) }
- def create_constant(name, type:, &block); end
-
- sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Extend).void)).returns(Parlour::RbsGenerator::Extend) }
- def create_extend(type, &block); end
-
- sig { params(extendables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Extend]) }
- def create_extends(extendables); end
-
- sig { params(type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Include).void)).returns(Parlour::RbsGenerator::Include) }
- def create_include(type, &block); end
-
- sig { params(includables: T::Array[T.any(Parlour::Types::Type, String)]).returns(T::Array[Parlour::RbsGenerator::Include]) }
- def create_includes(includables); end
-
- sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::InterfaceNamespace) }
- def create_interface(name, &block); end
-
- sig { params(name: String, signatures: T.nilable(T::Array[Parlour::RbsGenerator::MethodSignature]), class_method: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Method).void)).returns(Parlour::RbsGenerator::Method) }
- def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end
-
- sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)).returns(Parlour::RbsGenerator::ModuleNamespace) }
- def create_module(name, &block); end
-
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::TypeAlias).void)).returns(Parlour::RbsGenerator::TypeAlias) }
- def create_type_alias(name, type:, &block); end
-
- sig { override.overridable.returns(String) }
- def describe; end
-
- sig { returns(T::Array[Parlour::RbsGenerator::Extend]) }
- def extends; end
-
- sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { returns(T::Array[Parlour::RbsGenerator::Include]) }
- def includes; end
-
- sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.overridable.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void }
- def path(object, &block); end
-
- def type_aliases(*args, &blk); end
-
- private
-
- sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_body(indent_level, options); end
-
- sig { params(object: Parlour::RbsGenerator::RbsObject).void }
- def move_next_comments(object); end
-end
-
-class Parlour::RbsGenerator::Parameter
- sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), required: T::Boolean).void }
- def initialize(name, type: T.unsafe(nil), required: T.unsafe(nil)); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(Symbol) }
- def kind; end
-
- sig { returns(String) }
- def name; end
-
- sig { returns(String) }
- def name_without_kind; end
-
- sig { returns(T::Boolean) }
- def required; end
-
- sig { returns(String) }
- def to_rbs_param; end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array)
-
-class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject
- abstract!
-
- sig { params(generator: Parlour::Generator, name: String).void }
- def initialize(generator, name); end
-
- sig { override.overridable.returns(String) }
- def describe; end
-
- sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { returns(Parlour::Generator) }
- def generator; end
-
- sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { abstract.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-end
-
-class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject
- sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::TypeAlias).void)).void }
- def initialize(generator, name:, type:, &block); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_rbs(indent_level, options); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).void }
- def merge_into_self(others); end
-
- sig { override.params(others: T::Array[Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
- def mergeable?(others); end
-
- sig { returns(T.any(Parlour::Types::Type, String)) }
- def type; end
-end
-
-module Parlour::TypeLoader
- class << self
- sig { params(filename: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
- def load_file(filename, generator: T.unsafe(nil)); end
-
- sig { params(root: String, inclusions: T::Array[String], exclusions: T::Array[String], generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
- def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end
-
- sig { params(source: String, filename: T.nilable(String), generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::RbiGenerator::Namespace) }
- def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end
- end
-end
-
-class Parlour::TypeParser
- sig { params(ast: Parser::AST::Node, unknown_node_errors: T::Boolean, generator: T.nilable(Parlour::RbiGenerator)).void }
- def initialize(ast, unknown_node_errors: T.unsafe(nil), generator: T.unsafe(nil)); end
-
- sig { returns(Parser::AST::Node) }
- def ast; end
-
- def ast=(_arg0); end
-
- sig { returns(Parlour::RbiGenerator) }
- def generator; end
-
- def generator=(_arg0); end
-
- sig { returns(Parlour::RbiGenerator::Namespace) }
- def parse_all; end
-
- sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) }
- def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
-
- sig { params(node: Parser::AST::Node).returns(Parlour::Types::Type) }
- def parse_node_to_type(node); end
-
- sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
- def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end
-
- sig { params(path: Parlour::TypeParser::NodePath, is_within_eigenclass: T::Boolean).returns(T::Array[Parlour::RbiGenerator::Method]) }
- def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
-
- sig { params(path: Parlour::TypeParser::NodePath).returns(Parlour::TypeParser::IntermediateSig) }
- def parse_sig_into_sig(path); end
-
- sig { returns(T::Boolean) }
- def unknown_node_errors; end
-
- protected
-
- sig { params(node: T.nilable(Parser::AST::Node), modifier: Symbol).returns(T::Boolean) }
- def body_has_modifier?(node, modifier); end
-
- sig { params(node: Parser::AST::Node).returns([T::Array[String], T::Array[String]]) }
- def body_includes_and_extends(node); end
-
- sig { params(node: T.nilable(Parser::AST::Node)).returns(T::Array[Symbol]) }
- def constant_names(node); end
-
- sig { params(node: T.nilable(Parser::AST::Node)).returns(T.nilable(String)) }
- def node_to_s(node); end
-
- sig { params(desc: String, node: T.any(Parlour::TypeParser::NodePath, Parser::AST::Node)).returns(T.noreturn) }
- def parse_err(desc, node); end
-
- sig { params(path: Parlour::TypeParser::NodePath).returns(T::Boolean) }
- def previous_sibling_sig_node?(path); end
-
- sig { params(node: Parser::AST::Node).returns(T::Boolean) }
- def sig_node?(node); end
-
- sig { params(msg: String, node: Parser::AST::Node).void }
- def warning(msg, node); end
-
- sig { type_parameters(:A, :B).params(a: T::Array[T.type_parameter(:A)], fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped), b: T::Array[T.type_parameter(:B)], fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped)).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]]) }
- def zip_by(a, fa, b, fb); end
-
- class << self
- sig { params(filename: String, source: String, generator: T.nilable(Parlour::RbiGenerator)).returns(Parlour::TypeParser) }
- def from_source(filename, source, generator: T.unsafe(nil)); end
-
- sig { params(str: String).returns(Parlour::Types::Type) }
- def parse_single_type(str); end
- end
-end
-
-class Parlour::TypeParser::IntermediateSig < ::T::Struct
- prop :abstract, T::Boolean
- prop :final, T::Boolean
- prop :overridable, T::Boolean
- prop :override, T::Boolean
- prop :params, T.nilable(T::Array[Parser::AST::Node])
- prop :return_type, T.nilable(String)
- prop :type_parameters, T.nilable(T::Array[Symbol])
-
- class << self
- def inherited(s); end
- end
-end
-
-class Parlour::TypeParser::NodePath
- sig { params(indices: T::Array[Integer]).void }
- def initialize(indices); end
-
- sig { params(index: Integer).returns(Parlour::TypeParser::NodePath) }
- def child(index); end
-
- sig { returns(T::Array[Integer]) }
- def indices; end
-
- sig { returns(Parlour::TypeParser::NodePath) }
- def parent; end
-
- sig { params(offset: Integer).returns(Parlour::TypeParser::NodePath) }
- def sibling(offset); end
-
- sig { params(start: Parser::AST::Node).returns(Parser::AST::Node) }
- def traverse(start); end
-end
-
-class Parlour::TypedObject
- abstract!
-
- sig { params(name: String).void }
- def initialize(name); end
-
- sig { params(comment: T.any(String, T::Array[String])).void }
- def add_comment(comment); end
-
- def add_comments(*args, &blk); end
-
- sig { returns(T::Array[String]) }
- def comments; end
-
- sig { abstract.returns(String) }
- def describe; end
-
- sig { returns(T.nilable(Parlour::Plugin)) }
- def generated_by; end
-
- sig { returns(String) }
- def name; end
-
- protected
-
- sig { params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
- def generate_comments(indent_level, options); end
-end
-
-module Parlour::Types; end
-
-class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def collection_name; end
-end
-
-class Parlour::Types::Boolean < ::Parlour::Types::Type
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-end
-
-class Parlour::Types::Class < ::Parlour::Types::Type
- sig { params(type: T.any(Parlour::Types::Type, String)).void }
- def initialize(type); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(Parlour::Types::Type) }
- def type; end
-end
-
-class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def collection_name; end
-end
-
-class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def collection_name; end
-end
-
-class Parlour::Types::Generic < ::Parlour::Types::Type
- sig { params(type: T.any(Parlour::Types::Type, String), type_params: T::Array[T.any(Parlour::Types::Type, String)]).void }
- def initialize(type, type_params); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(Parlour::Types::Type) }
- def type; end
-
- sig { returns(T::Array[Parlour::Types::Type]) }
- def type_params; end
-end
-
-class Parlour::Types::Hash < ::Parlour::Types::Type
- sig { params(key: T.any(Parlour::Types::Type, String), value: T.any(Parlour::Types::Type, String)).void }
- def initialize(key, value); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(Parlour::Types::Type) }
- def key; end
-
- sig { returns(Parlour::Types::Type) }
- def value; end
-end
-
-class Parlour::Types::Intersection < ::Parlour::Types::Type
- sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void }
- def initialize(types); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(T::Array[Parlour::Types::Type]) }
- def types; end
-end
-
-class Parlour::Types::Nilable < ::Parlour::Types::Type
- sig { params(type: T.any(Parlour::Types::Type, String)).void }
- def initialize(type); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(Parlour::Types::Type) }
- def type; end
-end
-
-class Parlour::Types::Proc < ::Parlour::Types::Type
- sig { params(parameters: T::Array[Parlour::Types::Proc::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String))).void }
- def initialize(parameters, return_type); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(T::Array[Parlour::Types::Proc::Parameter]) }
- def parameters; end
-
- sig { returns(T.nilable(Parlour::Types::Type)) }
- def return_type; end
-end
-
-class Parlour::Types::Proc::Parameter
- sig { params(name: String, type: T.any(Parlour::Types::Type, String), default: T.nilable(String)).void }
- def initialize(name, type, default = T.unsafe(nil)); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { returns(T.nilable(String)) }
- def default; end
-
- sig { returns(String) }
- def name; end
-
- sig { returns(Parlour::Types::Type) }
- def type; end
-end
-
-class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def collection_name; end
-end
-
-class Parlour::Types::Raw < ::Parlour::Types::Type
- sig { params(str: String).void }
- def initialize(str); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(String) }
- def str; end
-end
-
-class Parlour::Types::Record < ::Parlour::Types::Type
- sig { params(keys_to_types: T::Hash[Symbol, T.any(Parlour::Types::Type, String)]).void }
- def initialize(keys_to_types); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(T::Hash[Symbol, Parlour::Types::Type]) }
- def keys_to_types; end
-end
-
-class Parlour::Types::Self < ::Parlour::Types::Type
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-end
-
-class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def collection_name; end
-end
-
-class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type
- abstract!
-
- sig { params(element: T.any(Parlour::Types::Type, String)).void }
- def initialize(element); end
-
- sig { abstract.returns(String) }
- def collection_name; end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { returns(Parlour::Types::Type) }
- def element; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-end
-
-class Parlour::Types::Tuple < ::Parlour::Types::Type
- sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void }
- def initialize(types); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(T::Array[Parlour::Types::Type]) }
- def types; end
-end
-
-class Parlour::Types::Type
- abstract!
-
- def initialize(*args, &blk); end
-
- sig { abstract.returns(String) }
- def describe; end
-
- sig { abstract.returns(String) }
- def generate_rbi; end
-
- sig { abstract.returns(String) }
- def generate_rbs; end
-
- def hash; end
-
- sig { params(type_like: T.any(Parlour::Types::Type, String)).returns(Parlour::Types::Type) }
- def to_type(type_like); end
-
- class << self
- sig { params(type_like: T.any(Parlour::Types::Type, String)).returns(Parlour::Types::Type) }
- def to_type(type_like); end
- end
-end
-
-Parlour::Types::TypeLike = T.type_alias { T.any(Parlour::Types::Type, String) }
-
-class Parlour::Types::Union < ::Parlour::Types::Type
- sig { params(types: T::Array[T.any(Parlour::Types::Type, String)]).void }
- def initialize(types); end
-
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-
- sig { returns(T::Array[Parlour::Types::Type]) }
- def types; end
-end
-
-class Parlour::Types::Untyped < ::Parlour::Types::Type
- sig { params(other: Object).returns(T::Boolean) }
- def ==(other); end
-
- sig { override.returns(String) }
- def describe; end
-
- sig { override.returns(String) }
- def generate_rbi; end
-
- sig { override.returns(String) }
- def generate_rbs; end
-end
-
-Parlour::VERSION = T.let(T.unsafe(nil), String) | true |
Other | Homebrew | brew | 48bf0cc7ad6acc119e75072b170a0b0ca4a5de9a.json | Update RBI files for parlour. | Library/Homebrew/sorbet/rbi/gems/parlour@7.0.0.rbi | @@ -0,0 +1,2154 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parlour` gem.
+# Please instead update this file by running `bin/tapioca gem parlour`.
+
+module Kernel
+ extend ::Forwardable
+end
+
+module Parlour; end
+
+class Parlour::ConflictResolver
+ def initialize; end
+
+ sig do
+ params(
+ namespace: Parlour::RbiGenerator::Namespace,
+ resolver: T.proc.params(desc: ::String, choices: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T.nilable(::Parlour::RbiGenerator::RbiObject))
+ ).void
+ end
+ def resolve_conflicts(namespace, &resolver); end
+
+ private
+
+ sig { params(arr: T::Array[T.untyped]).returns(T::Boolean) }
+ def all_eql?(arr); end
+
+ sig { params(namespace: Parlour::RbiGenerator::Namespace, name: T.nilable(::String)).void }
+ def deduplicate_mixins_of_name(namespace, name); end
+
+ sig { params(arr: T::Array[T.untyped]).returns(T.nilable(::Symbol)) }
+ def merge_strategy(arr); end
+end
+
+module Parlour::Conversion; end
+
+class Parlour::Conversion::Converter
+ abstract!
+
+ def initialize; end
+
+ sig { params(msg: ::String, node: ::Parlour::RbiGenerator::RbiObject).void }
+ def add_warning(msg, node); end
+
+ sig { returns(T::Array[[::String, ::Parlour::TypedObject]]) }
+ def warnings; end
+end
+
+class Parlour::Conversion::RbiToRbs < ::Parlour::Conversion::Converter
+ sig { params(rbs_gen: ::Parlour::RbsGenerator).void }
+ def initialize(rbs_gen); end
+
+ sig { params(from: Parlour::RbiGenerator::Namespace, to: Parlour::RbsGenerator::Namespace).void }
+ def convert_all(from, to); end
+
+ sig { params(node: ::Parlour::RbiGenerator::RbiObject, new_parent: Parlour::RbsGenerator::Namespace).void }
+ def convert_object(node, new_parent); end
+
+ sig { returns(::Parlour::RbsGenerator) }
+ def rbs_gen; end
+end
+
+module Parlour::Debugging
+ class << self
+ sig { params(value: T::Boolean).returns(T::Boolean) }
+ def debug_mode=(value); end
+
+ sig { returns(T::Boolean) }
+ def debug_mode?; end
+
+ sig { params(object: T.untyped, message: ::String).void }
+ def debug_puts(object, message); end
+
+ sig { params(object: T.untyped).returns(::String) }
+ def name_for_debug_caller(object); end
+ end
+end
+
+class Parlour::Debugging::Tree
+ sig { params(colour: T::Boolean).void }
+ def initialize(colour: T.unsafe(nil)); end
+
+ sig { params(message: ::String).returns(::String) }
+ def begin(message); end
+
+ sig { returns(T::Boolean) }
+ def colour; end
+
+ sig { params(message: ::String).returns(::String) }
+ def end(message); end
+
+ sig { params(message: ::String).returns(::String) }
+ def here(message); end
+
+ def indent!(offset); end
+ def line_prefix; end
+ def text_prefix; end
+end
+
+Parlour::Debugging::Tree::INDENT_SPACES = T.let(T.unsafe(nil), Integer)
+
+class Parlour::DetachedRbiGenerator < ::Parlour::RbiGenerator
+ sig { override.returns(T.nilable(::Parlour::Plugin)) }
+ def current_plugin; end
+
+ sig { returns(T.untyped) }
+ def detached!; end
+
+ sig { override.returns(::Parlour::Options) }
+ def options; end
+
+ sig { override.params(strictness: ::String).returns(::String) }
+ def rbi(strictness = T.unsafe(nil)); end
+end
+
+class Parlour::DetachedRbsGenerator < ::Parlour::RbsGenerator
+ sig { override.returns(T.nilable(::Parlour::Plugin)) }
+ def current_plugin; end
+
+ sig { returns(T.untyped) }
+ def detached!; end
+
+ sig { override.returns(::Parlour::Options) }
+ def options; end
+
+ sig { override.returns(::String) }
+ def rbs; end
+end
+
+class Parlour::Generator
+ sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void }
+ def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end
+
+ sig { overridable.returns(T.nilable(::Parlour::Plugin)) }
+ def current_plugin; end
+
+ def current_plugin=(_arg0); end
+
+ sig { overridable.returns(::Parlour::Options) }
+ def options; end
+end
+
+module Parlour::Mixin; end
+
+module Parlour::Mixin::Searchable
+ extend T::Generic
+
+ abstract!
+
+ Child = type_member
+
+ sig { abstract.returns(T::Array[Child]) }
+ def children; end
+
+ sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(Child) }
+ def find(name: T.unsafe(nil), type: T.unsafe(nil)); end
+
+ sig { params(name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Array[Child]) }
+ def find_all(name: T.unsafe(nil), type: T.unsafe(nil)); end
+
+ private
+
+ sig { params(child: Child, name: T.nilable(::String), type: T.nilable(::Class)).returns(T::Boolean) }
+ def searchable_child_matches(child, name, type); end
+end
+
+class Parlour::Options
+ sig { params(break_params: ::Integer, tab_size: ::Integer, sort_namespaces: T::Boolean).void }
+ def initialize(break_params:, tab_size:, sort_namespaces:); end
+
+ sig { returns(::Integer) }
+ def break_params; end
+
+ sig { params(level: ::Integer, str: ::String).returns(::String) }
+ def indented(level, str); end
+
+ sig { returns(T::Boolean) }
+ def sort_namespaces; end
+
+ sig { returns(::Integer) }
+ def tab_size; end
+end
+
+class Parlour::ParseError < ::StandardError
+ def initialize(buffer, range); end
+
+ sig { returns(::Parser::Source::Buffer) }
+ def buffer; end
+
+ sig { returns(::Parser::Source::Range) }
+ def range; end
+end
+
+class Parlour::Plugin
+ abstract!
+
+ sig { params(options: T::Hash[T.untyped, T.untyped]).void }
+ def initialize(options); end
+
+ sig { abstract.params(root: Parlour::RbiGenerator::Namespace).void }
+ def generate(root); end
+
+ sig { returns(T.nilable(::String)) }
+ def strictness; end
+
+ def strictness=(_arg0); end
+
+ class << self
+ sig { params(new_plugin: T.class_of(Parlour::Plugin)).void }
+ def inherited(new_plugin); end
+
+ sig { returns(T::Hash[::String, T.class_of(Parlour::Plugin)]) }
+ def registered_plugins; end
+
+ sig do
+ params(
+ plugins: T::Array[::Parlour::Plugin],
+ generator: ::Parlour::RbiGenerator,
+ allow_failure: T::Boolean
+ ).void
+ end
+ def run_plugins(plugins, generator, allow_failure: T.unsafe(nil)); end
+ end
+end
+
+class Parlour::RbiGenerator < ::Parlour::Generator
+ def initialize(**hash); end
+
+ sig { overridable.params(strictness: ::String).returns(::String) }
+ def rbi(strictness = T.unsafe(nil)); end
+
+ sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
+ def root; end
+end
+
+class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ code: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Arbitrary).void)
+ ).void
+ end
+ def initialize(generator, code: T.unsafe(nil), &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(::String) }
+ def code; end
+
+ def code=(_arg0); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ kind: ::Symbol,
+ type: T.any(::Parlour::Types::Type, ::String),
+ class_attribute: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
+ ).void
+ end
+ def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end
+
+ sig { override.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T::Boolean) }
+ def class_attribute; end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { returns(::Symbol) }
+ def kind; end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+
+ private
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_definition(indent_level, options); end
+end
+
+class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ superclass: T.nilable(::String),
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
+ ).void
+ end
+ def initialize(generator, name, final, sealed, superclass, abstract, &block); end
+
+ sig { returns(T::Boolean) }
+ def abstract; end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.nilable(::String)) }
+ def superclass; end
+end
+
+class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ value: T.any(::Parlour::Types::Type, ::String),
+ eigen_constant: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void)
+ ).void
+ end
+ def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ def eigen_constant; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def value; end
+end
+
+class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ enums: T::Array[T.any(::String, [::String, ::String])],
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)
+ ).void
+ end
+ def initialize(generator, name, final, sealed, enums, abstract, &block); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { returns(T::Array[T.any(::String, [::String, ::String])]) }
+ def enums; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_body(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void)
+ ).void
+ end
+ def initialize(generator, name: T.unsafe(nil), &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void)
+ ).void
+ end
+ def initialize(generator, name: T.unsafe(nil), &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ parameters: T::Array[::Parlour::RbiGenerator::Parameter],
+ return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ abstract: T::Boolean,
+ implementation: T::Boolean,
+ override: T::Boolean,
+ overridable: T::Boolean,
+ class_method: T::Boolean,
+ final: T::Boolean,
+ type_parameters: T.nilable(T::Array[::Symbol]),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void)
+ ).void
+ end
+ def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
+
+ sig { overridable.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T::Boolean) }
+ def abstract; end
+
+ sig { returns(T::Boolean) }
+ def class_method; end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { returns(T::Boolean) }
+ def final; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { returns(T::Boolean) }
+ def implementation; end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T::Boolean) }
+ def overridable; end
+
+ sig { returns(T::Boolean) }
+ def override; end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::Parameter]) }
+ def parameters; end
+
+ sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
+ def return_type; end
+
+ sig { returns(T::Array[::Symbol]) }
+ def type_parameters; end
+
+ private
+
+ sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_definition(indent_level, options); end
+
+ sig { returns(::String) }
+ def qualifiers; end
+end
+
+class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ interface: T::Boolean,
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
+ ).void
+ end
+ def initialize(generator, name, final, sealed, interface, abstract, &block); end
+
+ sig { returns(T::Boolean) }
+ def abstract; end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { returns(T::Boolean) }
+ def interface; end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
+ extend T::Generic
+ include ::Parlour::Mixin::Searchable
+
+ Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: T.nilable(::String),
+ final: T::Boolean,
+ sealed: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)
+ ).void
+ end
+ def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end
+
+ sig { params(comment: T.any(::String, T::Array[::String])).void }
+ def add_comment_to_next_child(comment); end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::TypeAlias]) }
+ def aliases; end
+
+ sig { override.returns(T::Array[::Parlour::RbiGenerator::RbiObject]) }
+ def children; end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::Constant]) }
+ def constants; end
+
+ def create_arbitrary(code:, &block); end
+ def create_attr(*args, &blk); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ class_attribute: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
+ ).returns(::Parlour::RbiGenerator::Attribute)
+ end
+ def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ class_attribute: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
+ ).returns(::Parlour::RbiGenerator::Attribute)
+ end
+ def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ class_attribute: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
+ ).returns(::Parlour::RbiGenerator::Attribute)
+ end
+ def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ kind: ::Symbol,
+ type: T.any(::Parlour::Types::Type, ::String),
+ class_attribute: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Attribute).void)
+ ).returns(::Parlour::RbiGenerator::Attribute)
+ end
+ def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ superclass: T.nilable(::String),
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
+ ).returns(Parlour::RbiGenerator::ClassNamespace)
+ end
+ def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ value: ::String,
+ eigen_constant: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Constant).void)
+ ).returns(::Parlour::RbiGenerator::Constant)
+ end
+ def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ enums: T.nilable(T::Array[T.any(::String, [::String, ::String])]),
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)
+ ).returns(Parlour::RbiGenerator::EnumClassNamespace)
+ end
+ def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Extend).void)
+ ).returns(::Parlour::RbiGenerator::Extend)
+ end
+ def create_extend(name, &block); end
+
+ sig { params(extendables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Extend]) }
+ def create_extends(extendables); end
+
+ sig do
+ params(
+ name: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Include).void)
+ ).returns(::Parlour::RbiGenerator::Include)
+ end
+ def create_include(name, &block); end
+
+ sig { params(includables: T::Array[::String]).returns(T::Array[::Parlour::RbiGenerator::Include]) }
+ def create_includes(includables); end
+
+ sig do
+ params(
+ name: ::String,
+ parameters: T.nilable(T::Array[::Parlour::RbiGenerator::Parameter]),
+ return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ returns: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ abstract: T::Boolean,
+ implementation: T::Boolean,
+ override: T::Boolean,
+ overridable: T::Boolean,
+ class_method: T::Boolean,
+ final: T::Boolean,
+ type_parameters: T.nilable(T::Array[::Symbol]),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::Method).void)
+ ).returns(::Parlour::RbiGenerator::Method)
+ end
+ def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ interface: T::Boolean,
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)
+ ).returns(Parlour::RbiGenerator::ModuleNamespace)
+ end
+ def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ props: T.nilable(T::Array[::Parlour::RbiGenerator::StructProp]),
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)
+ ).returns(Parlour::RbiGenerator::StructClassNamespace)
+ end
+ def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void)
+ ).returns(::Parlour::RbiGenerator::TypeAlias)
+ end
+ def create_type_alias(name, type:, &block); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::Extend]) }
+ def extends; end
+
+ sig { returns(T::Boolean) }
+ def final; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::Include]) }
+ def includes; end
+
+ sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.overridable.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { params(constant: ::Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
+ def path(constant, &block); end
+
+ sig { returns(T::Boolean) }
+ def sealed; end
+
+ def type_aliases(*args, &blk); end
+
+ private
+
+ sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_body(indent_level, options); end
+
+ sig { params(object: ::Parlour::RbiGenerator::RbiObject).void }
+ def move_next_comments(object); end
+end
+
+Parlour::RbiGenerator::Options = Parlour::Options
+
+class Parlour::RbiGenerator::Parameter
+ sig do
+ params(
+ name: ::String,
+ type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ default: T.nilable(::String)
+ ).void
+ end
+ def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T.nilable(::String)) }
+ def default; end
+
+ sig { returns(::String) }
+ def describe_in_method; end
+
+ sig { void }
+ def generalize_from_rbi!; end
+
+ sig { returns(::Symbol) }
+ def kind; end
+
+ sig { returns(::String) }
+ def name; end
+
+ sig { returns(::String) }
+ def name_without_kind; end
+
+ sig { returns(::String) }
+ def to_def_param; end
+
+ sig { returns(::String) }
+ def to_sig_param; end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
+
+class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
+ abstract!
+
+ sig { params(generator: ::Parlour::Generator, name: ::String).void }
+ def initialize(generator, name); end
+
+ sig { abstract.void }
+ def generalize_from_rbi!; end
+
+ sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { returns(::Parlour::Generator) }
+ def generator; end
+
+ sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { abstract.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbiGenerator::RbiObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ final: T::Boolean,
+ sealed: T::Boolean,
+ props: T::Array[::Parlour::RbiGenerator::StructProp],
+ abstract: T::Boolean,
+ block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)
+ ).void
+ end
+ def initialize(generator, name, final, sealed, props, abstract, &block); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_body(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T::Array[::Parlour::RbiGenerator::StructProp]) }
+ def props; end
+end
+
+class Parlour::RbiGenerator::StructProp
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ optional: T.nilable(T.any(::Symbol, T::Boolean)),
+ enum: T.nilable(::String),
+ dont_store: T.nilable(T::Boolean),
+ foreign: T.nilable(::String),
+ default: T.nilable(::String),
+ factory: T.nilable(::String),
+ immutable: T.nilable(T::Boolean),
+ array: T.nilable(::String),
+ override: T.nilable(T::Boolean),
+ redaction: T.nilable(::String)
+ ).void
+ end
+ def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T.nilable(::String)) }
+ def array; end
+
+ sig { returns(T.nilable(::String)) }
+ def default; end
+
+ sig { returns(T.nilable(T::Boolean)) }
+ def dont_store; end
+
+ sig { returns(T.nilable(::String)) }
+ def enum; end
+
+ sig { returns(T.nilable(::String)) }
+ def factory; end
+
+ sig { returns(T.nilable(::String)) }
+ def foreign; end
+
+ sig { void }
+ def generalize_from_rbi!; end
+
+ sig { returns(T.nilable(T::Boolean)) }
+ def immutable; end
+
+ sig { returns(::String) }
+ def name; end
+
+ sig { returns(T.nilable(T.any(::Symbol, T::Boolean))) }
+ def optional; end
+
+ sig { returns(T.nilable(T::Boolean)) }
+ def override; end
+
+ sig { returns(T.nilable(::String)) }
+ def redaction; end
+
+ sig { returns(::String) }
+ def to_prop_call; end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array)
+
+class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbiGenerator::TypeAlias).void)
+ ).void
+ end
+ def initialize(generator, name:, type:, &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.void }
+ def generalize_from_rbi!; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbi(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+class Parlour::RbsGenerator < ::Parlour::Generator
+ def initialize(**hash); end
+
+ sig { overridable.returns(::String) }
+ def rbs; end
+
+ sig { overridable.returns(Parlour::RbsGenerator::Namespace) }
+ def root; end
+end
+
+class Parlour::RbsGenerator::Arbitrary < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ code: ::String,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Arbitrary).void)
+ ).void
+ end
+ def initialize(generator, code: T.unsafe(nil), &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(::String) }
+ def code; end
+
+ def code=(_arg0); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbsGenerator::Attribute < ::Parlour::RbsGenerator::Method
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ kind: ::Symbol,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
+ ).void
+ end
+ def initialize(generator, name, kind, type, &block); end
+
+ sig { override.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { returns(::Symbol) }
+ def kind; end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+class Parlour::RbsGenerator::Block
+ sig { params(type: ::Parlour::Types::Proc, required: T::Boolean).void }
+ def initialize(type, required); end
+
+ sig { overridable.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { params(options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(options); end
+
+ sig { returns(T::Boolean) }
+ def required; end
+
+ sig { returns(::Parlour::Types::Proc) }
+ def type; end
+end
+
+class Parlour::RbsGenerator::ClassNamespace < ::Parlour::RbsGenerator::Namespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)
+ ).void
+ end
+ def initialize(generator, name, superclass, &block); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
+ def superclass; end
+end
+
+class Parlour::RbsGenerator::Constant < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void)
+ ).void
+ end
+ def initialize(generator, name, type:, &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+class Parlour::RbsGenerator::Extend < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void)
+ ).void
+ end
+ def initialize(generator, type:, &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+class Parlour::RbsGenerator::Include < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void)
+ ).void
+ end
+ def initialize(generator, type:, &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+class Parlour::RbsGenerator::InterfaceNamespace < ::Parlour::RbsGenerator::Namespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+end
+
+class Parlour::RbsGenerator::Method < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ signatures: T::Array[::Parlour::RbsGenerator::MethodSignature],
+ class_method: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void)
+ ).void
+ end
+ def initialize(generator, name, signatures, class_method: T.unsafe(nil), &block); end
+
+ sig { overridable.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T::Boolean) }
+ def class_method; end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::MethodSignature]) }
+ def signatures; end
+end
+
+class Parlour::RbsGenerator::MethodSignature
+ sig do
+ params(
+ parameters: T::Array[::Parlour::RbsGenerator::Parameter],
+ return_type: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ block: T.nilable(::Parlour::RbsGenerator::Block),
+ type_parameters: T.nilable(T::Array[::Symbol])
+ ).void
+ end
+ def initialize(parameters, return_type = T.unsafe(nil), block: T.unsafe(nil), type_parameters: T.unsafe(nil)); end
+
+ sig { overridable.params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T.nilable(::Parlour::RbsGenerator::Block)) }
+ def block; end
+
+ sig { returns(::String) }
+ def describe_in_method; end
+
+ sig { params(options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(options); end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::Parameter]) }
+ def parameters; end
+
+ sig { returns(T.nilable(T.any(::Parlour::Types::Type, ::String))) }
+ def return_type; end
+
+ sig { returns(T::Array[::Symbol]) }
+ def type_parameters; end
+end
+
+class Parlour::RbsGenerator::ModuleNamespace < ::Parlour::RbsGenerator::Namespace
+ extend T::Generic
+
+ Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+end
+
+class Parlour::RbsGenerator::Namespace < ::Parlour::RbsGenerator::RbsObject
+ extend T::Generic
+ include ::Parlour::Mixin::Searchable
+
+ Child = type_member { { fixed: Parlour::RbsGenerator::RbsObject } }
+
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: T.nilable(::String),
+ block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
+ ).void
+ end
+ def initialize(generator, name = T.unsafe(nil), &block); end
+
+ sig { params(comment: T.any(::String, T::Array[::String])).void }
+ def add_comment_to_next_child(comment); end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::TypeAlias]) }
+ def aliases; end
+
+ sig { override.returns(T::Array[::Parlour::RbsGenerator::RbsObject]) }
+ def children; end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::Constant]) }
+ def constants; end
+
+ def create_arbitrary(code:, &block); end
+ def create_attr(*args, &blk); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
+ ).returns(::Parlour::RbsGenerator::Attribute)
+ end
+ def create_attr_accessor(name, type:, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
+ ).returns(::Parlour::RbsGenerator::Attribute)
+ end
+ def create_attr_reader(name, type:, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
+ ).returns(::Parlour::RbsGenerator::Attribute)
+ end
+ def create_attr_writer(name, type:, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ kind: ::Symbol,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Attribute).void)
+ ).returns(::Parlour::RbsGenerator::Attribute)
+ end
+ def create_attribute(name, kind:, type:, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ superclass: T.nilable(T.any(::Parlour::Types::Type, ::String)),
+ block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::ClassNamespace).void)
+ ).returns(Parlour::RbsGenerator::ClassNamespace)
+ end
+ def create_class(name, superclass: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Constant).void)
+ ).returns(::Parlour::RbsGenerator::Constant)
+ end
+ def create_constant(name, type:, &block); end
+
+ sig do
+ params(
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Extend).void)
+ ).returns(::Parlour::RbsGenerator::Extend)
+ end
+ def create_extend(type, &block); end
+
+ sig do
+ params(
+ extendables: T::Array[T.any(::Parlour::Types::Type, ::String)]
+ ).returns(T::Array[::Parlour::RbsGenerator::Extend])
+ end
+ def create_extends(extendables); end
+
+ sig do
+ params(
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Include).void)
+ ).returns(::Parlour::RbsGenerator::Include)
+ end
+ def create_include(type, &block); end
+
+ sig do
+ params(
+ includables: T::Array[T.any(::Parlour::Types::Type, ::String)]
+ ).returns(T::Array[::Parlour::RbsGenerator::Include])
+ end
+ def create_includes(includables); end
+
+ sig do
+ params(
+ name: ::String,
+ block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
+ ).returns(Parlour::RbsGenerator::InterfaceNamespace)
+ end
+ def create_interface(name, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ signatures: T.nilable(T::Array[::Parlour::RbsGenerator::MethodSignature]),
+ class_method: T::Boolean,
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::Method).void)
+ ).returns(::Parlour::RbsGenerator::Method)
+ end
+ def create_method(name, signatures = T.unsafe(nil), class_method: T.unsafe(nil), &block); end
+
+ sig do
+ params(
+ name: ::String,
+ block: T.nilable(T.proc.params(x: Parlour::RbsGenerator::Namespace).void)
+ ).returns(Parlour::RbsGenerator::ModuleNamespace)
+ end
+ def create_module(name, &block); end
+
+ sig do
+ params(
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void)
+ ).returns(::Parlour::RbsGenerator::TypeAlias)
+ end
+ def create_type_alias(name, type:, &block); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::Extend]) }
+ def extends; end
+
+ sig { override.overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { returns(T::Array[::Parlour::RbsGenerator::Include]) }
+ def includes; end
+
+ sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.overridable.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { params(object: T.untyped, block: T.proc.params(x: Parlour::RbsGenerator::Namespace).void).void }
+ def path(object, &block); end
+
+ def type_aliases(*args, &blk); end
+
+ private
+
+ sig { overridable.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_body(indent_level, options); end
+
+ sig { params(object: ::Parlour::RbsGenerator::RbsObject).void }
+ def move_next_comments(object); end
+end
+
+class Parlour::RbsGenerator::Parameter
+ sig { params(name: ::String, type: T.nilable(T.any(::Parlour::Types::Type, ::String)), required: T::Boolean).void }
+ def initialize(name, type: T.unsafe(nil), required: T.unsafe(nil)); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(::Symbol) }
+ def kind; end
+
+ sig { returns(::String) }
+ def name; end
+
+ sig { returns(::String) }
+ def name_without_kind; end
+
+ sig { returns(T::Boolean) }
+ def required; end
+
+ sig { returns(::String) }
+ def to_rbs_param; end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+Parlour::RbsGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
+Parlour::RbsGenerator::Parameter::RBS_KEYWORDS = T.let(T.unsafe(nil), Array)
+
+class Parlour::RbsGenerator::RbsObject < ::Parlour::TypedObject
+ abstract!
+
+ sig { params(generator: ::Parlour::Generator, name: ::String).void }
+ def initialize(generator, name); end
+
+ sig { abstract.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { returns(::Parlour::Generator) }
+ def generator; end
+
+ sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { abstract.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+end
+
+class Parlour::RbsGenerator::TypeAlias < ::Parlour::RbsGenerator::RbsObject
+ sig do
+ params(
+ generator: ::Parlour::Generator,
+ name: ::String,
+ type: T.any(::Parlour::Types::Type, ::String),
+ block: T.nilable(T.proc.params(x: ::Parlour::RbsGenerator::TypeAlias).void)
+ ).void
+ end
+ def initialize(generator, name:, type:, &block); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { override.params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_rbs(indent_level, options); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).void }
+ def merge_into_self(others); end
+
+ sig { override.params(others: T::Array[::Parlour::RbsGenerator::RbsObject]).returns(T::Boolean) }
+ def mergeable?(others); end
+
+ sig { returns(T.any(::Parlour::Types::Type, ::String)) }
+ def type; end
+end
+
+module Parlour::TypeLoader
+ class << self
+ sig do
+ params(
+ filename: ::String,
+ generator: T.nilable(::Parlour::RbiGenerator)
+ ).returns(Parlour::RbiGenerator::Namespace)
+ end
+ def load_file(filename, generator: T.unsafe(nil)); end
+
+ sig do
+ params(
+ root: ::String,
+ inclusions: T::Array[::String],
+ exclusions: T::Array[::String],
+ generator: T.nilable(::Parlour::RbiGenerator)
+ ).returns(Parlour::RbiGenerator::Namespace)
+ end
+ def load_project(root, inclusions: T.unsafe(nil), exclusions: T.unsafe(nil), generator: T.unsafe(nil)); end
+
+ sig do
+ params(
+ source: ::String,
+ filename: T.nilable(::String),
+ generator: T.nilable(::Parlour::RbiGenerator)
+ ).returns(Parlour::RbiGenerator::Namespace)
+ end
+ def load_source(source, filename = T.unsafe(nil), generator: T.unsafe(nil)); end
+ end
+end
+
+class Parlour::TypeParser
+ sig do
+ params(
+ ast: ::Parser::AST::Node,
+ unknown_node_errors: T::Boolean,
+ generator: T.nilable(::Parlour::RbiGenerator)
+ ).void
+ end
+ def initialize(ast, unknown_node_errors: T.unsafe(nil), generator: T.unsafe(nil)); end
+
+ sig { returns(::Parser::AST::Node) }
+ def ast; end
+
+ def ast=(_arg0); end
+
+ sig { returns(::Parlour::RbiGenerator) }
+ def generator; end
+
+ def generator=(_arg0); end
+
+ sig { returns(Parlour::RbiGenerator::Namespace) }
+ def parse_all; end
+
+ sig do
+ params(
+ path: ::Parlour::TypeParser::NodePath,
+ is_within_eigenclass: T::Boolean
+ ).returns(T::Array[::Parlour::RbiGenerator::Method])
+ end
+ def parse_method_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
+
+ sig { params(node: ::Parser::AST::Node).returns(::Parlour::Types::Type) }
+ def parse_node_to_type(node); end
+
+ sig do
+ params(
+ path: ::Parlour::TypeParser::NodePath,
+ is_within_eigenclass: T::Boolean
+ ).returns(T::Array[::Parlour::RbiGenerator::RbiObject])
+ end
+ def parse_path_to_object(path, is_within_eigenclass: T.unsafe(nil)); end
+
+ sig do
+ params(
+ path: ::Parlour::TypeParser::NodePath,
+ is_within_eigenclass: T::Boolean
+ ).returns(T::Array[::Parlour::RbiGenerator::Method])
+ end
+ def parse_sig_into_methods(path, is_within_eigenclass: T.unsafe(nil)); end
+
+ sig { params(path: ::Parlour::TypeParser::NodePath).returns(::Parlour::TypeParser::IntermediateSig) }
+ def parse_sig_into_sig(path); end
+
+ sig { returns(T::Boolean) }
+ def unknown_node_errors; end
+
+ protected
+
+ sig { params(node: T.nilable(::Parser::AST::Node), modifier: ::Symbol).returns(T::Boolean) }
+ def body_has_modifier?(node, modifier); end
+
+ sig { params(node: ::Parser::AST::Node).returns([T::Array[::String], T::Array[::String]]) }
+ def body_includes_and_extends(node); end
+
+ sig { params(node: T.nilable(::Parser::AST::Node)).returns(T::Array[::Symbol]) }
+ def constant_names(node); end
+
+ sig { params(node: T.nilable(::Parser::AST::Node)).returns(T.nilable(::String)) }
+ def node_to_s(node); end
+
+ sig { params(desc: ::String, node: T.any(::Parlour::TypeParser::NodePath, ::Parser::AST::Node)).returns(T.noreturn) }
+ def parse_err(desc, node); end
+
+ sig { params(path: ::Parlour::TypeParser::NodePath).returns(T::Boolean) }
+ def previous_sibling_sig_node?(path); end
+
+ sig { params(node: ::Parser::AST::Node).returns(T::Boolean) }
+ def sig_node?(node); end
+
+ sig { params(msg: ::String, node: ::Parser::AST::Node).void }
+ def warning(msg, node); end
+
+ sig do
+ type_parameters(:A, :B)
+ .params(
+ a: T::Array[T.type_parameter(:A)],
+ fa: T.proc.params(item: T.type_parameter(:A)).returns(T.untyped),
+ b: T::Array[T.type_parameter(:B)],
+ fb: T.proc.params(item: T.type_parameter(:B)).returns(T.untyped)
+ ).returns(T::Array[[T.type_parameter(:A), T.type_parameter(:B)]])
+ end
+ def zip_by(a, fa, b, fb); end
+
+ class << self
+ sig do
+ params(
+ filename: ::String,
+ source: ::String,
+ generator: T.nilable(::Parlour::RbiGenerator)
+ ).returns(::Parlour::TypeParser)
+ end
+ def from_source(filename, source, generator: T.unsafe(nil)); end
+
+ sig { params(str: ::String).returns(::Parlour::Types::Type) }
+ def parse_single_type(str); end
+ end
+end
+
+class Parlour::TypeParser::IntermediateSig < ::T::Struct
+ prop :abstract, T::Boolean
+ prop :final, T::Boolean
+ prop :overridable, T::Boolean
+ prop :override, T::Boolean
+ prop :params, T.nilable(T::Array[::Parser::AST::Node])
+ prop :return_type, T.nilable(::String)
+ prop :type_parameters, T.nilable(T::Array[::Symbol])
+
+ class << self
+ def inherited(s); end
+ end
+end
+
+class Parlour::TypeParser::NodePath
+ sig { params(indices: T::Array[::Integer]).void }
+ def initialize(indices); end
+
+ sig { params(index: ::Integer).returns(::Parlour::TypeParser::NodePath) }
+ def child(index); end
+
+ sig { returns(T::Array[::Integer]) }
+ def indices; end
+
+ sig { returns(::Parlour::TypeParser::NodePath) }
+ def parent; end
+
+ sig { params(offset: ::Integer).returns(::Parlour::TypeParser::NodePath) }
+ def sibling(offset); end
+
+ sig { params(start: ::Parser::AST::Node).returns(::Parser::AST::Node) }
+ def traverse(start); end
+end
+
+class Parlour::TypedObject
+ abstract!
+
+ sig { params(name: ::String).void }
+ def initialize(name); end
+
+ sig { params(comment: T.any(::String, T::Array[::String])).void }
+ def add_comment(comment); end
+
+ def add_comments(*args, &blk); end
+
+ sig { returns(T::Array[::String]) }
+ def comments; end
+
+ sig { returns(::String) }
+ def describe; end
+
+ sig { params(tree: T.nilable(::Parlour::Debugging::Tree)).returns(::String) }
+ def describe_tree(tree: T.unsafe(nil)); end
+
+ sig { returns(T.nilable(::Parlour::Plugin)) }
+ def generated_by; end
+
+ def inspect(*args, &blk); end
+
+ sig { returns(::String) }
+ def name; end
+
+ def to_s(*args, &blk); end
+
+ protected
+
+ sig { abstract.returns(T::Array[T.any(::Symbol, T::Hash[::Symbol, ::String])]) }
+ def describe_attrs; end
+
+ sig { params(indent_level: ::Integer, options: ::Parlour::Options).returns(T::Array[::String]) }
+ def generate_comments(indent_level, options); end
+end
+
+module Parlour::Types; end
+
+class Parlour::Types::Array < ::Parlour::Types::SingleElementCollection
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def collection_name; end
+end
+
+class Parlour::Types::Boolean < ::Parlour::Types::Type
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+end
+
+class Parlour::Types::Class < ::Parlour::Types::Type
+ sig { params(type: T.any(::Parlour::Types::Type, ::String)).void }
+ def initialize(type); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def type; end
+end
+
+class Parlour::Types::Enumerable < ::Parlour::Types::SingleElementCollection
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def collection_name; end
+end
+
+class Parlour::Types::Enumerator < ::Parlour::Types::SingleElementCollection
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def collection_name; end
+end
+
+class Parlour::Types::Generic < ::Parlour::Types::Type
+ sig do
+ params(
+ type: T.any(::Parlour::Types::Type, ::String),
+ type_params: T::Array[T.any(::Parlour::Types::Type, ::String)]
+ ).void
+ end
+ def initialize(type, type_params); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def type; end
+
+ sig { returns(T::Array[::Parlour::Types::Type]) }
+ def type_params; end
+end
+
+class Parlour::Types::Hash < ::Parlour::Types::Type
+ sig { params(key: T.any(::Parlour::Types::Type, ::String), value: T.any(::Parlour::Types::Type, ::String)).void }
+ def initialize(key, value); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def key; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def value; end
+end
+
+class Parlour::Types::Intersection < ::Parlour::Types::Type
+ sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
+ def initialize(types); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(T::Array[::Parlour::Types::Type]) }
+ def types; end
+end
+
+class Parlour::Types::Nilable < ::Parlour::Types::Type
+ sig { params(type: T.any(::Parlour::Types::Type, ::String)).void }
+ def initialize(type); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def type; end
+end
+
+class Parlour::Types::Proc < ::Parlour::Types::Type
+ sig do
+ params(
+ parameters: T::Array[::Parlour::Types::Proc::Parameter],
+ return_type: T.nilable(T.any(::Parlour::Types::Type, ::String))
+ ).void
+ end
+ def initialize(parameters, return_type); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(T::Array[::Parlour::Types::Proc::Parameter]) }
+ def parameters; end
+
+ sig { returns(T.nilable(::Parlour::Types::Type)) }
+ def return_type; end
+end
+
+class Parlour::Types::Proc::Parameter
+ sig { params(name: ::String, type: T.any(::Parlour::Types::Type, ::String), default: T.nilable(::String)).void }
+ def initialize(name, type, default = T.unsafe(nil)); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { returns(T.nilable(::String)) }
+ def default; end
+
+ sig { returns(::String) }
+ def name; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def type; end
+end
+
+class Parlour::Types::Range < ::Parlour::Types::SingleElementCollection
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def collection_name; end
+end
+
+class Parlour::Types::Raw < ::Parlour::Types::Type
+ sig { params(str: ::String).void }
+ def initialize(str); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(::String) }
+ def str; end
+end
+
+class Parlour::Types::Record < ::Parlour::Types::Type
+ sig { params(keys_to_types: T::Hash[::Symbol, T.any(::Parlour::Types::Type, ::String)]).void }
+ def initialize(keys_to_types); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(T::Hash[::Symbol, ::Parlour::Types::Type]) }
+ def keys_to_types; end
+end
+
+class Parlour::Types::Self < ::Parlour::Types::Type
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+end
+
+class Parlour::Types::Set < ::Parlour::Types::SingleElementCollection
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def collection_name; end
+end
+
+class Parlour::Types::SingleElementCollection < ::Parlour::Types::Type
+ abstract!
+
+ sig { params(element: T.any(::Parlour::Types::Type, ::String)).void }
+ def initialize(element); end
+
+ sig { abstract.returns(::String) }
+ def collection_name; end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { returns(::Parlour::Types::Type) }
+ def element; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+end
+
+class Parlour::Types::Tuple < ::Parlour::Types::Type
+ sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
+ def initialize(types); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(T::Array[::Parlour::Types::Type]) }
+ def types; end
+end
+
+class Parlour::Types::Type
+ abstract!
+
+ def initialize(*args, &blk); end
+
+ sig { abstract.returns(::String) }
+ def describe; end
+
+ sig { abstract.returns(::String) }
+ def generate_rbi; end
+
+ sig { abstract.returns(::String) }
+ def generate_rbs; end
+
+ def hash; end
+
+ sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) }
+ def to_type(type_like); end
+
+ class << self
+ sig { params(type_like: T.any(::Parlour::Types::Type, ::String)).returns(::Parlour::Types::Type) }
+ def to_type(type_like); end
+ end
+end
+
+Parlour::Types::TypeLike = T.type_alias { T.any(::Parlour::Types::Type, ::String) }
+
+class Parlour::Types::Union < ::Parlour::Types::Type
+ sig { params(types: T::Array[T.any(::Parlour::Types::Type, ::String)]).void }
+ def initialize(types); end
+
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+
+ sig { returns(T::Array[::Parlour::Types::Type]) }
+ def types; end
+end
+
+class Parlour::Types::Untyped < ::Parlour::Types::Type
+ sig { params(other: ::Object).returns(T::Boolean) }
+ def ==(other); end
+
+ sig { override.returns(::String) }
+ def describe; end
+
+ sig { override.returns(::String) }
+ def generate_rbi; end
+
+ sig { override.returns(::String) }
+ def generate_rbs; end
+end
+
+Parlour::VERSION = T.let(T.unsafe(nil), String) | true |
Other | Homebrew | brew | 48bf0cc7ad6acc119e75072b170a0b0ca4a5de9a.json | Update RBI files for parlour. | Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi | @@ -3931,7 +3931,7 @@ class Parlour::Conversion::Converter
extend ::T::Private::Methods::SingletonMethodHooks
end
-module Parlour::Debugging::Tree
+class Parlour::Debugging::Tree
extend ::T::Sig
extend ::T::Private::Methods::MethodHooks
extend ::T::Private::Methods::SingletonMethodHooks
@@ -3949,6 +3949,14 @@ class Parlour::Generator
extend ::T::Private::Methods::SingletonMethodHooks
end
+module Parlour::Mixin::Searchable
+ extend ::T::Sig
+ extend ::T::Private::Abstract::Hooks
+ extend ::T::InterfaceWrapper::Helpers
+ extend ::T::Private::Methods::MethodHooks
+ extend ::T::Private::Methods::SingletonMethodHooks
+end
+
class Parlour::Options
extend ::T::Sig
extend ::T::Private::Methods::MethodHooks | true |
Other | Homebrew | brew | 12dfa1fbd214bd0950335ffbed697153847d09ab.json | Update RBI files for tapioca. | Library/Homebrew/sorbet/rbi/gems/tapioca@0.7.2.rbi | @@ -75,8 +75,17 @@ class RBI::Tree < ::RBI::NodeWithComments
sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).void }
def create_path(constant, &block); end
- sig { params(name: ::String, value: ::String).void }
- def create_type_member(name, value: T.unsafe(nil)); end
+ sig do
+ params(
+ name: ::String,
+ type: ::String,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).void
+ end
+ def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
sig { params(annotation: ::String).void }
def deannotate!(annotation); end
@@ -142,8 +151,8 @@ RBI::VERSION = T.let(T.unsafe(nil), String)
module T::Generic::TypeStoragePatch
def [](*types); end
- def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
- def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
+ def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &blk); end
+ def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil), &blk); end
end
module T::Types::Simple::GenericPatch
@@ -1375,7 +1384,12 @@ module Tapioca::Runtime::Reflection
sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
def constants_of(constant); end
- sig { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
+ sig do
+ type_parameters(:U)
+ .params(
+ klass: T.all(::Class, T.type_parameter(:U))
+ ).returns(T::Array[T.type_parameter(:U)])
+ end
def descendants_of(klass); end
sig { params(constant: ::Module).returns(T::Array[::Module]) }
@@ -1639,6 +1653,23 @@ class Tapioca::TypeVariable < ::T::Types::TypeVariable
def name; end
end
+module Tapioca::TypeVariableHelper
+ extend ::Tapioca::SorbetHelper
+
+ class << self
+ sig do
+ params(
+ type: ::String,
+ variance: ::Symbol,
+ fixed: T.nilable(::String),
+ upper: T.nilable(::String),
+ lower: T.nilable(::String)
+ ).returns(::String)
+ end
+ def serialize_type_variable(type, variance, fixed, upper, lower); end
+ end
+end
+
class Tapioca::TypeVariableModule < ::Module
sig do
params(
@@ -1650,7 +1681,7 @@ class Tapioca::TypeVariableModule < ::Module
upper: T.untyped
).void
end
- def initialize(context, type, variance, fixed, lower, upper); end
+ def initialize(context, type, variance, fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
sig { returns(::Tapioca::TypeVariable) }
def coerce_to_type_variable; end | false |
Other | Homebrew | brew | 3aaef294f6564adaf99c80d6ccf3ed1150c16d34.json | formula_installer: add check for HOMEBREW_RELOCATE_BUILD_PREFIX | Library/Homebrew/formula_installer.rb | @@ -1235,6 +1235,8 @@ def pour
prefix = Pathname(cellar).parent.to_s
return if cellar == HOMEBREW_CELLAR.to_s && prefix == HOMEBREW_PREFIX.to_s
+ return unless ENV["HOMEBREW_RELOCATE_BUILD_PREFIX"]
+
keg.relocate_build_prefix(keg, prefix, HOMEBREW_PREFIX)
end
| false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.