diff --git a/Gemfile.lock b/Gemfile.lock
index 13aa29f..012909c 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -9,7 +9,7 @@ PATH
GEM
remote: https://rubygems.org/
specs:
- activesupport (7.1.2)
+ activesupport (7.1.3)
base64
bigdecimal
concurrent-ruby (~> 1.0, >= 1.0.2)
@@ -21,9 +21,9 @@ GEM
tzinfo (~> 2.0)
ast (2.4.2)
base64 (0.2.0)
- bigdecimal (3.1.5)
+ bigdecimal (3.1.6)
coderay (1.1.3)
- concurrent-ruby (1.2.2)
+ concurrent-ruby (1.2.3)
connection_pool (2.4.1)
dotenv (2.8.1)
drb (2.2.0)
diff --git a/sorbet/rbi/gems/activesupport@7.1.2.rbi b/sorbet/rbi/gems/activesupport@7.1.3.rbi
similarity index 96%
rename from sorbet/rbi/gems/activesupport@7.1.2.rbi
rename to sorbet/rbi/gems/activesupport@7.1.3.rbi
index ca355e9..bc47ea6 100644
--- a/sorbet/rbi/gems/activesupport@7.1.2.rbi
+++ b/sorbet/rbi/gems/activesupport@7.1.3.rbi
@@ -1098,13 +1098,13 @@ ActiveSupport::Cache::FileStore::GITKEEP_FILES = T.let(T.unsafe(nil), Array)
# a cleanup will occur which tries to prune the cache down to three quarters
# of the maximum size by removing the least recently used entries.
#
-# Unlike other Cache store implementations, MemoryStore does not compress
-# values by default. MemoryStore does not benefit from compression as much
+# Unlike other Cache store implementations, +MemoryStore+ does not compress
+# values by default. +MemoryStore+ does not benefit from compression as much
# as other Store implementations, as it does not send data over a network.
# However, when compression is enabled, it still pays the full cost of
# compression in terms of cpu use.
#
-# MemoryStore is thread-safe.
+# +MemoryStore+ is thread-safe.
#
# source://activesupport//lib/active_support/cache/memory_store.rb#28
class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
@@ -1271,7 +1271,7 @@ class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
private
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#159
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#162
def delete_entry(key, **_arg1); end
# source://activesupport//lib/active_support/cache/null_store.rb#42
@@ -1283,7 +1283,7 @@ class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
# source://activesupport//lib/active_support/cache/null_store.rb#49
def write_entry(key, entry, **_arg2); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#150
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#153
def write_serialized_entry(key, payload, **_arg2); end
class << self
@@ -1449,8 +1449,8 @@ ActiveSupport::Cache::SerializerWithFallback::SERIALIZERS = T.let(T.unsafe(nil),
# Some implementations may not support all methods beyond the basic cache
# methods of #fetch, #write, #read, #exist?, and #delete.
#
-# ActiveSupport::Cache::Store can store any Ruby object that is supported by
-# its +coder+'s +dump+ and +load+ methods.
+# +ActiveSupport::Cache::Store+ can store any Ruby object that is supported
+# by its +coder+'s +dump+ and +load+ methods.
#
# cache = ActiveSupport::Cache::MemoryStore.new
#
@@ -1649,8 +1649,8 @@ class ActiveSupport::Cache::Store
#
# ==== Options
#
- # Internally, +fetch+ calls #read_entry, and calls #write_entry on a cache
- # miss. Thus, +fetch+ supports the same options as #read and #write.
+ # Internally, +fetch+ calls +read_entry+, and calls +write_entry+ on a
+ # cache miss. Thus, +fetch+ supports the same options as #read and #write.
# Additionally, +fetch+ supports the following options:
#
# * force: true - Forces a cache "miss," meaning we treat the
@@ -1912,7 +1912,7 @@ class ActiveSupport::Cache::Store
def delete_multi_entries(entries, **options); end
# source://activesupport//lib/active_support/cache.rb#821
- def deserialize_entry(payload); end
+ def deserialize_entry(payload, **_arg1); end
# Expands key to be a consistent string value. Invokes +cache_key+ if
# object responds to +cache_key+. Otherwise, +to_param+ method will be
@@ -2078,31 +2078,31 @@ module ActiveSupport::Cache::Strategy::LocalCache
private
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#182
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#185
def bypass_local_cache(&block); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#159
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#162
def delete_entry(key, **_arg1); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#178
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#181
def local_cache; end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#174
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#177
def local_cache_key; end
# source://activesupport//lib/active_support/cache/strategy/local_cache.rb#134
- def read_multi_entries(keys, **options); end
+ def read_multi_entries(names, **options); end
# source://activesupport//lib/active_support/cache/strategy/local_cache.rb#120
def read_serialized_entry(key, raw: T.unsafe(nil), **options); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#186
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#189
def use_temporary_local_cache(temporary_cache); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#164
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#167
def write_cache_value(name, value, **options); end
- # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#150
+ # source://activesupport//lib/active_support/cache/strategy/local_cache.rb#153
def write_serialized_entry(key, payload, **_arg2); end
end
@@ -2180,29 +2180,42 @@ end
# source://activesupport//lib/active_support/cache.rb#26
ActiveSupport::Cache::UNIVERSAL_OPTIONS = T.let(T.unsafe(nil), Array)
-# source://activesupport//lib/active_support/cache.rb#1067
+# Enables the dynamic configuration of Cache entry options while ensuring
+# that conflicting options are not both set. When a block is given to
+# ActiveSupport::Cache::Store#fetch, the second argument will be an
+# instance of +WriteOptions+.
+#
+# source://activesupport//lib/active_support/cache.rb#1071
class ActiveSupport::Cache::WriteOptions
# @return [WriteOptions] a new instance of WriteOptions
#
- # source://activesupport//lib/active_support/cache.rb#1068
+ # source://activesupport//lib/active_support/cache.rb#1072
def initialize(options); end
- # source://activesupport//lib/active_support/cache.rb#1089
+ # source://activesupport//lib/active_support/cache.rb#1096
def expires_at; end
- # source://activesupport//lib/active_support/cache.rb#1093
+ # Sets the Cache entry's +expires_at+ value. If an +expires_in+ option was
+ # previously set, this will unset it since +expires_at+ and +expires_in+
+ # cannot both be set.
+ #
+ # source://activesupport//lib/active_support/cache.rb#1103
def expires_at=(expires_at); end
- # source://activesupport//lib/active_support/cache.rb#1080
+ # source://activesupport//lib/active_support/cache.rb#1084
def expires_in; end
- # source://activesupport//lib/active_support/cache.rb#1084
+ # Sets the Cache entry's +expires_in+ value. If an +expires_at+ option was
+ # previously set, this will unset it since +expires_in+ and +expires_at+
+ # cannot both be set.
+ #
+ # source://activesupport//lib/active_support/cache.rb#1091
def expires_in=(expires_in); end
- # source://activesupport//lib/active_support/cache.rb#1072
+ # source://activesupport//lib/active_support/cache.rb#1076
def version; end
- # source://activesupport//lib/active_support/cache.rb#1076
+ # source://activesupport//lib/active_support/cache.rb#1080
def version=(version); end
end
@@ -4017,15 +4030,15 @@ end
# You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
# constant. Available behaviors are:
#
-# [+raise+] Raise ActiveSupport::DeprecationException.
-# [+stderr+] Log all deprecation warnings to $stderr.
-# [+log+] Log all deprecation warnings to +Rails.logger+.
-# [+notify+] Use ActiveSupport::Notifications to notify +deprecation.rails+.
-# [+report+] Use ActiveSupport::ErrorReporter to report deprecations.
-# [+silence+] Do nothing. On \Rails, set config.active_support.report_deprecations = false to disable all behaviors.
+# [+:raise+] Raise ActiveSupport::DeprecationException.
+# [+:stderr+] Log all deprecation warnings to $stderr.
+# [+:log+] Log all deprecation warnings to +Rails.logger+.
+# [+:notify+] Use ActiveSupport::Notifications to notify +deprecation.rails+.
+# [+:report+] Use ActiveSupport::ErrorReporter to report deprecations.
+# [+:silence+] Do nothing. On \Rails, set config.active_support.report_deprecations = false to disable all behaviors.
#
# Setting behaviors only affects deprecations that happen after boot time.
-# For more information you can read the documentation of the +behavior=+ method.
+# For more information you can read the documentation of the #behavior= method.
#
# source://activesupport//lib/active_support/deprecation/behaviors.rb#69
module ActiveSupport::Deprecation::Behavior
@@ -4039,12 +4052,12 @@ module ActiveSupport::Deprecation::Behavior
#
# Available behaviors:
#
- # [+raise+] Raise ActiveSupport::DeprecationException.
- # [+stderr+] Log all deprecation warnings to $stderr.
- # [+log+] Log all deprecation warnings to +Rails.logger+.
- # [+notify+] Use ActiveSupport::Notifications to notify +deprecation.rails+.
- # [+report+] Use ActiveSupport::ErrorReporter to report deprecations.
- # [+silence+] Do nothing.
+ # [+:raise+] Raise ActiveSupport::DeprecationException.
+ # [+:stderr+] Log all deprecation warnings to $stderr.
+ # [+:log+] Log all deprecation warnings to +Rails.logger+.
+ # [+:notify+] Use ActiveSupport::Notifications to notify +deprecation.rails+.
+ # [+:report+] Use ActiveSupport::ErrorReporter to report deprecations.
+ # [+:silence+] Do nothing.
#
# Setting behaviors only affects deprecations that happen after boot time.
# Deprecation warnings raised by gems are not affected by this setting
@@ -4058,10 +4071,12 @@ module ActiveSupport::Deprecation::Behavior
# # custom stuff
# }
#
- # If you are using \Rails, you can set config.active_support.report_deprecations = false to disable
- # all deprecation behaviors. This is similar to the +silence+ option but more performant.
+ # If you are using \Rails, you can set
+ # config.active_support.report_deprecations = false to disable
+ # all deprecation behaviors. This is similar to the +:silence+ option but
+ # more performant.
#
- # source://activesupport//lib/active_support/deprecation/behaviors.rb#109
+ # source://activesupport//lib/active_support/deprecation/behaviors.rb#111
def behavior=(behavior); end
# Whether to print a backtrace along with the warning.
@@ -4081,18 +4096,18 @@ module ActiveSupport::Deprecation::Behavior
# Sets the behavior for disallowed deprecations (those configured by
# ActiveSupport::Deprecation#disallowed_warnings=) to the specified
- # value. As with +behavior=+, this can be a single value, array, or an
+ # value. As with #behavior=, this can be a single value, array, or an
# object that responds to +call+.
#
- # source://activesupport//lib/active_support/deprecation/behaviors.rb#117
+ # source://activesupport//lib/active_support/deprecation/behaviors.rb#119
def disallowed_behavior=(behavior); end
private
- # source://activesupport//lib/active_support/deprecation/behaviors.rb#122
+ # source://activesupport//lib/active_support/deprecation/behaviors.rb#124
def arity_coerce(behavior); end
- # source://activesupport//lib/active_support/deprecation/behaviors.rb#141
+ # source://activesupport//lib/active_support/deprecation/behaviors.rb#143
def arity_of_callable(callable); end
end
@@ -4592,7 +4607,7 @@ module ActiveSupport::Deprecation::Reporting
private
- # source://activesupport//lib/active_support/deprecation/reporting.rb#151
+ # source://activesupport//lib/active_support/deprecation/reporting.rb#153
def _extract_callstack(callstack); end
# Outputs a deprecation warning message
@@ -4616,11 +4631,16 @@ module ActiveSupport::Deprecation::Reporting
# source://activesupport//lib/active_support/deprecation/reporting.rb#140
def extract_callstack(callstack); end
- # source://activesupport//lib/active_support/deprecation/reporting.rb#166
- def ignored_callstack(path); end
+ # @return [Boolean]
+ #
+ # source://activesupport//lib/active_support/deprecation/reporting.rb#169
+ def ignored_callstack?(path); end
end
-# source://activesupport//lib/active_support/deprecation/reporting.rb#164
+# source://activesupport//lib/active_support/deprecation/reporting.rb#167
+ActiveSupport::Deprecation::Reporting::LIB_DIR = T.let(T.unsafe(nil), String)
+
+# source://activesupport//lib/active_support/deprecation/reporting.rb#166
ActiveSupport::Deprecation::Reporting::RAILS_GEM_ROOT = T.let(T.unsafe(nil), String)
# Raised when ActiveSupport::Deprecation::Behavior#behavior is set with :raise.
@@ -8781,10 +8801,10 @@ class ActiveSupport::Notifications::Fanout
# source://activesupport//lib/active_support/notifications/fanout.rb#314
def listening?(name); end
- # source://mutex_m/0.2.0/lib/mutex_m.rb#91
+ # source://mutex_m/0.2.0/mutex_m.rb#91
def lock; end
- # source://mutex_m/0.2.0/lib/mutex_m.rb#81
+ # source://mutex_m/0.2.0/mutex_m.rb#81
def locked?; end
# source://activesupport//lib/active_support/notifications/fanout.rb#293
@@ -8799,13 +8819,13 @@ class ActiveSupport::Notifications::Fanout
# source://activesupport//lib/active_support/notifications/fanout.rb#68
def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
- # source://mutex_m/0.2.0/lib/mutex_m.rb#76
+ # source://mutex_m/0.2.0/mutex_m.rb#76
def synchronize(&block); end
- # source://mutex_m/0.2.0/lib/mutex_m.rb#86
+ # source://mutex_m/0.2.0/mutex_m.rb#86
def try_lock; end
- # source://mutex_m/0.2.0/lib/mutex_m.rb#96
+ # source://mutex_m/0.2.0/mutex_m.rb#96
def unlock; end
# source://activesupport//lib/active_support/notifications/fanout.rb#85
@@ -9147,379 +9167,433 @@ module ActiveSupport::NumberHelper
extend ::ActiveSupport::Autoload
extend ::ActiveSupport::NumberHelper
- # Formats a +number+ into a currency string (e.g., $13.65). You
- # can customize the format in the +options+ hash.
+ # Formats a +number+ into a currency string.
+ #
+ # number_to_currency(1234567890.50) # => "$1,234,567,890.50"
+ # number_to_currency(1234567890.506) # => "$1,234,567,890.51"
+ # number_to_currency("12x34") # => "$12x34"
+ #
+ # number_to_currency(1234567890.50, unit: "£", separator: ",", delimiter: "")
+ # # => "£1234567890,50"
#
# The currency unit and number formatting of the current locale will be used
- # unless otherwise specified in the provided options. No currency conversion
- # is performed. If the user is given a way to change their locale, they will
+ # unless otherwise specified via options. No currency conversion is
+ # performed. If the user is given a way to change their locale, they will
# also be able to change the relative value of the currency displayed with
# this helper. If your application will ever support multiple locales, you
- # may want to specify a constant :locale option or consider
- # using a library capable of currency conversion.
+ # may want to specify a constant +:locale+ option or consider using a
+ # library capable of currency conversion.
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :precision - Sets the level of precision (defaults
- # to 2).
- # * :round_mode - Determine how rounding is performed
- # (defaults to :default. See BigDecimal::mode)
- # * :unit - Sets the denomination of the currency
- # (defaults to "$").
- # * :separator - Sets the separator between the units
- # (defaults to ".").
- # * :delimiter - Sets the thousands delimiter (defaults
- # to ",").
- # * :format - Sets the format for non-negative numbers
- # (defaults to "%u%n"). Fields are %u for the
- # currency, and %n for the number.
- # * :negative_format - Sets the format for negative
- # numbers (defaults to prepending a hyphen to the formatted
- # number given by :format). Accepts the same fields
- # than :format, except %n is here the
- # absolute value of the number.
- # * :strip_insignificant_zeros - If +true+ removes
- # insignificant zeros after the decimal separator (defaults to
- # +false+).
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
#
- # ==== Examples
+ # number_to_currency(1234567890.506, locale: :fr)
+ # # => "1 234 567 890,51 €"
#
- # number_to_currency(1234567890.50) # => "$1,234,567,890.50"
- # number_to_currency(1234567890.506) # => "$1,234,567,890.51"
- # number_to_currency(1234567890.506, precision: 3) # => "$1,234,567,890.506"
- # number_to_currency(1234567890.506, locale: :fr) # => "1 234 567 890,51 €"
- # number_to_currency('123a456') # => "$123a456"
- #
- # number_to_currency(-0.456789, precision: 0)
- # # => "$0"
- # number_to_currency(-1234567890.50, negative_format: '(%u%n)')
- # # => "($1,234,567,890.50)"
- # number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '')
- # # => "£1234567890,50"
- # number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '', format: '%n %u')
- # # => "1234567890,50 £"
- # number_to_currency(1234567890.50, strip_insignificant_zeros: true)
- # # => "$1,234,567,890.5"
- # number_to_currency(1234567890.50, precision: 0, round_mode: :up)
- # # => "$1,234,567,891"
- #
- # source://activesupport//lib/active_support/number_helper.rb#114
+ # [+:precision+]
+ # The level of precision. Defaults to 2.
+ #
+ # number_to_currency(1234567890.123, precision: 3) # => "$1,234,567,890.123"
+ # number_to_currency(0.456789, precision: 0) # => "$0"
+ #
+ # [+:round_mode+]
+ # Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+ # +:default+.
+ #
+ # number_to_currency(1234567890.01, precision: 0, round_mode: :up)
+ # # => "$1,234,567,891"
+ #
+ # [+:unit+]
+ # The denomination of the currency. Defaults to "$".
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
+ #
+ # [+:format+]
+ # The format for non-negative numbers. %u represents the currency,
+ # and %n represents the number. Defaults to "%u%n".
+ #
+ # number_to_currency(1234567890.50, format: "%n %u")
+ # # => "1,234,567,890.50 $"
+ #
+ # [+:negative_format+]
+ # The format for negative numbers. %u and %n behave the
+ # same as in +:format+, but %n represents the absolute value of
+ # the number. Defaults to the value of +:format+ prepended with -.
+ #
+ # number_to_currency(-1234567890.50, negative_format: "(%u%n)")
+ # # => "($1,234,567,890.50)"
+ #
+ # [+:strip_insignificant_zeros+]
+ # Whether to remove insignificant zeros after the decimal separator.
+ # Defaults to false.
+ #
+ # number_to_currency(1234567890.50, strip_insignificant_zeros: true)
+ # # => "$1,234,567,890.5"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#139
def number_to_currency(number, options = T.unsafe(nil)); end
- # Formats a +number+ with grouped thousands using +delimiter+
- # (e.g., 12,324). You can customize the format in the +options+
- # hash.
+ # Formats +number+ by grouping thousands with a delimiter.
+ #
+ # number_to_delimited(12345678) # => "12,345,678"
+ # number_to_delimited("123456") # => "123,456"
+ # number_to_delimited(12345678.9876) # => "12,345,678.9876"
+ # number_to_delimited("12x34") # => "12x34"
+ #
+ # number_to_delimited(12345678.9876, delimiter: ".", separator: ",")
+ # # => "12.345.678,9876"
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :delimiter - Sets the thousands delimiter (defaults
- # to ",").
- # * :separator - Sets the separator between the
- # fractional and integer digits (defaults to ".").
- # * :delimiter_pattern - Sets a custom regular expression used for
- # deriving the placement of delimiter. Helpful when using currency formats
- # like INR.
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
#
- # ==== Examples
+ # number_to_delimited(12345678.05, locale: :fr)
+ # # => "12 345 678,05"
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
#
- # number_to_delimited(12345678) # => "12,345,678"
- # number_to_delimited('123456') # => "123,456"
- # number_to_delimited(12345678.05) # => "12,345,678.05"
- # number_to_delimited(12345678, delimiter: '.') # => "12.345.678"
- # number_to_delimited(12345678, delimiter: ',') # => "12,345,678"
- # number_to_delimited(12345678.05, separator: ' ') # => "12,345,678 05"
- # number_to_delimited(12345678.05, locale: :fr) # => "12 345 678,05"
- # number_to_delimited('112a') # => "112a"
- # number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
- # # => "98 765 432,98"
- # number_to_delimited("123456.78",
- # delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
- # # => "1,23,456.78"
- #
- # source://activesupport//lib/active_support/number_helper.rb#189
+ # number_to_delimited(12345678, delimiter: ".")
+ # # => "12.345.678"
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # number_to_delimited(12345678.05, separator: " ")
+ # # => "12,345,678 05"
+ #
+ # [+:delimiter_pattern+]
+ # A regexp to determine the placement of delimiters. Helpful when using
+ # currency formats like INR.
+ #
+ # number_to_delimited("123456.78", delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
+ # # => "1,23,456.78"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#242
def number_to_delimited(number, options = T.unsafe(nil)); end
- # Pretty prints (formats and approximates) a number in a way it
- # is more readable by humans (e.g.: 1200000000 becomes "1.2
- # Billion"). This is useful for numbers that can get very large
- # (and too hard to read).
+ # Formats +number+ into a more human-friendly representation. Useful for
+ # numbers that can become very large and too hard to read.
#
- # See number_to_human_size if you want to print a file
- # size.
+ # number_to_human(123) # => "123"
+ # number_to_human(1234) # => "1.23 Thousand"
+ # number_to_human(12345) # => "12.3 Thousand"
+ # number_to_human(1234567) # => "1.23 Million"
+ # number_to_human(1234567890) # => "1.23 Billion"
+ # number_to_human(1234567890123) # => "1.23 Trillion"
+ # number_to_human(1234567890123456) # => "1.23 Quadrillion"
+ # number_to_human(1234567890123456789) # => "1230 Quadrillion"
#
- # You can also define your own unit-quantifier names if you want
- # to use other decimal units (e.g.: 1500 becomes "1.5
- # kilometers", 0.150 becomes "150 milliliters", etc). You may
- # define a wide range of unit quantifiers, even fractional ones
- # (centi, deci, mili, etc).
+ # See #number_to_human_size if you want to pretty-print a file size.
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :precision - Sets the precision of the number
- # (defaults to 3).
- # * :round_mode - Determine how rounding is performed
- # (defaults to :default. See BigDecimal::mode)
- # * :significant - If +true+, precision will be the number
- # of significant_digits. If +false+, the number of fractional
- # digits (defaults to +true+)
- # * :separator - Sets the separator between the
- # fractional and integer digits (defaults to ".").
- # * :delimiter - Sets the thousands delimiter (defaults
- # to "").
- # * :strip_insignificant_zeros - If +true+ removes
- # insignificant zeros after the decimal separator (defaults to
- # +true+)
- # * :units - A Hash of unit quantifier names. Or a
- # string containing an i18n scope where to find this hash. It
- # might have the following keys:
- # * *integers*: :unit, :ten,
- # :hundred, :thousand, :million,
- # :billion, :trillion,
- # :quadrillion
- # * *fractionals*: :deci, :centi,
- # :mili, :micro, :nano,
- # :pico, :femto
- # * :format - Sets the format of the output string
- # (defaults to "%n %u"). The field types are:
- # * %u - The quantifier (ex.: 'thousand')
- # * %n - The number
- #
- # ==== Examples
- #
- # number_to_human(123) # => "123"
- # number_to_human(1234) # => "1.23 Thousand"
- # number_to_human(12345) # => "12.3 Thousand"
- # number_to_human(1234567) # => "1.23 Million"
- # number_to_human(1234567890) # => "1.23 Billion"
- # number_to_human(1234567890123) # => "1.23 Trillion"
- # number_to_human(1234567890123456) # => "1.23 Quadrillion"
- # number_to_human(1234567890123456789) # => "1230 Quadrillion"
- # number_to_human(489939, precision: 2) # => "490 Thousand"
- # number_to_human(489939, precision: 4) # => "489.9 Thousand"
- # number_to_human(489939, precision: 2
- # , round_mode: :down) # => "480 Thousand"
- # number_to_human(1234567, precision: 4,
- # significant: false) # => "1.2346 Million"
- # number_to_human(1234567, precision: 1,
- # separator: ',',
- # significant: false) # => "1,2 Million"
- #
- # number_to_human(500000000, precision: 5) # => "500 Million"
- # number_to_human(12345012345, significant: false) # => "12.345 Billion"
- #
- # Non-significant zeros after the decimal separator are stripped
- # out by default (set :strip_insignificant_zeros to
- # +false+ to change that):
- #
- # number_to_human(12.00001) # => "12"
- # number_to_human(12.00001, strip_insignificant_zeros: false) # => "12.0"
- #
- # ==== Custom Unit Quantifiers
- #
- # You can also use your own custom unit quantifiers:
- #
- # number_to_human(500000, units: { unit: 'ml', thousand: 'lt' }) # => "500 lt"
- #
- # If in your I18n locale you have:
- #
- # distance:
- # centi:
- # one: "centimeter"
- # other: "centimeters"
- # unit:
- # one: "meter"
- # other: "meters"
- # thousand:
- # one: "kilometer"
- # other: "kilometers"
- # billion: "gazillion-distance"
- #
- # Then you could do:
- #
- # number_to_human(543934, units: :distance) # => "544 kilometers"
- # number_to_human(54393498, units: :distance) # => "54400 kilometers"
- # number_to_human(54393498000, units: :distance) # => "54.4 gazillion-distance"
- # number_to_human(343, units: :distance, precision: 1) # => "300 meters"
- # number_to_human(1, units: :distance) # => "1 meter"
- # number_to_human(0.34, units: :distance) # => "34 centimeters"
- #
- # source://activesupport//lib/active_support/number_helper.rb#392
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
+ #
+ # [+:precision+]
+ # The level of precision. Defaults to 3.
+ #
+ # number_to_human(123456, precision: 2) # => "120 Thousand"
+ # number_to_human(123456, precision: 4) # => "123.5 Thousand"
+ #
+ # [+:round_mode+]
+ # Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+ # +:default+.
+ #
+ # number_to_human(123456, precision: 2, round_mode: :up)
+ # # => "130 Thousand"
+ #
+ # [+:significant+]
+ # Whether +:precision+ should be applied to significant digits instead of
+ # fractional digits. Defaults to true.
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # number_to_human(123456, precision: 4, separator: ",")
+ # # => "123,5 Thousand"
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
+ #
+ # [+:strip_insignificant_zeros+]
+ # Whether to remove insignificant zeros after the decimal separator.
+ # Defaults to true.
+ #
+ # number_to_human(1000000) # => "1 Million"
+ # number_to_human(1000000, strip_insignificant_zeros: false) # => "1.00 Million"
+ # number_to_human(10.01) # => "10"
+ # number_to_human(10.01, strip_insignificant_zeros: false) # => "10.0"
+ #
+ # [+:format+]
+ # The format of the output. %n represents the number, and
+ # %u represents the quantifier (e.g., "Thousand"). Defaults to
+ # "%n %u".
+ #
+ # [+:units+]
+ # A Hash of custom unit quantifier names.
+ #
+ # number_to_human(1, units: { unit: "m", thousand: "km" }) # => "1 m"
+ # number_to_human(100, units: { unit: "m", thousand: "km" }) # => "100 m"
+ # number_to_human(1000, units: { unit: "m", thousand: "km" }) # => "1 km"
+ # number_to_human(100000, units: { unit: "m", thousand: "km" }) # => "100 km"
+ # number_to_human(10000000, units: { unit: "m", thousand: "km" }) # => "10000 km"
+ #
+ # The following keys are supported for integer units: +:unit+, +:ten+,
+ # +:hundred+, +:thousand+, +:million+, +:billion+, +:trillion+,
+ # +:quadrillion+. Additionally, the following keys are supported for
+ # fractional units: +:deci+, +:centi+, +:mili+, +:micro+, +:nano+,
+ # +:pico+, +:femto+.
+ #
+ # The Hash can also be defined as a scope in an I18n locale. For example:
+ #
+ # en:
+ # distance:
+ # centi:
+ # one: "centimeter"
+ # other: "centimeters"
+ # unit:
+ # one: "meter"
+ # other: "meters"
+ # thousand:
+ # one: "kilometer"
+ # other: "kilometers"
+ #
+ # Then it can be specified by name:
+ #
+ # number_to_human(1, units: :distance) # => "1 meter"
+ # number_to_human(100, units: :distance) # => "100 meters"
+ # number_to_human(1000, units: :distance) # => "1 kilometer"
+ # number_to_human(100000, units: :distance) # => "100 kilometers"
+ # number_to_human(10000000, units: :distance) # => "10000 kilometers"
+ # number_to_human(0.1, units: :distance) # => "10 centimeters"
+ # number_to_human(0.01, units: :distance) # => "1 centimeter"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#453
def number_to_human(number, options = T.unsafe(nil)); end
- # Formats the bytes in +number+ into a more understandable
- # representation (e.g., giving it 1500 yields 1.46 KB). This
- # method is useful for reporting file sizes to users. You can
- # customize the format in the +options+ hash.
+ # Formats +number+ as bytes into a more human-friendly representation.
+ # Useful for reporting file sizes to users.
+ #
+ # number_to_human_size(123) # => "123 Bytes"
+ # number_to_human_size(1234) # => "1.21 KB"
+ # number_to_human_size(12345) # => "12.1 KB"
+ # number_to_human_size(1234567) # => "1.18 MB"
+ # number_to_human_size(1234567890) # => "1.15 GB"
+ # number_to_human_size(1234567890123) # => "1.12 TB"
+ # number_to_human_size(1234567890123456) # => "1.1 PB"
+ # number_to_human_size(1234567890123456789) # => "1.07 EB"
#
- # See number_to_human if you want to pretty-print a
- # generic number.
+ # See #number_to_human if you want to pretty-print a generic number.
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :precision - Sets the precision of the number
- # (defaults to 3).
- # * :round_mode - Determine how rounding is performed
- # (defaults to :default. See BigDecimal::mode)
- # * :significant - If +true+, precision will be the number
- # of significant_digits. If +false+, the number of fractional
- # digits (defaults to +true+)
- # * :separator - Sets the separator between the
- # fractional and integer digits (defaults to ".").
- # * :delimiter - Sets the thousands delimiter (defaults
- # to "").
- # * :strip_insignificant_zeros - If +true+ removes
- # insignificant zeros after the decimal separator (defaults to
- # +true+)
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
#
- # ==== Examples
+ # [+:precision+]
+ # The level of precision. Defaults to 3.
+ #
+ # number_to_human_size(123456, precision: 2) # => "120 KB"
+ # number_to_human_size(1234567, precision: 2) # => "1.2 MB"
+ #
+ # [+:round_mode+]
+ # Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+ # +:default+.
#
- # number_to_human_size(123) # => "123 Bytes"
- # number_to_human_size(1234) # => "1.21 KB"
- # number_to_human_size(12345) # => "12.1 KB"
- # number_to_human_size(1234567) # => "1.18 MB"
- # number_to_human_size(1234567890) # => "1.15 GB"
- # number_to_human_size(1234567890123) # => "1.12 TB"
- # number_to_human_size(1234567890123456) # => "1.1 PB"
- # number_to_human_size(1234567890123456789) # => "1.07 EB"
- # number_to_human_size(1234567, precision: 2) # => "1.2 MB"
- # number_to_human_size(483989, precision: 2) # => "470 KB"
- # number_to_human_size(483989, precision: 2, round_mode: :up) # => "480 KB"
- # number_to_human_size(1234567, precision: 2, separator: ',') # => "1,2 MB"
- # number_to_human_size(1234567890123, precision: 5) # => "1.1228 TB"
- # number_to_human_size(524288000, precision: 5) # => "500 MB"
- #
- # source://activesupport//lib/active_support/number_helper.rb#283
+ # number_to_human_size(123456, precision: 2, round_mode: :up)
+ # # => "130 KB"
+ #
+ # [+:significant+]
+ # Whether +:precision+ should be applied to significant digits instead of
+ # fractional digits. Defaults to true.
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # number_to_human_size(1234567, separator: ",")
+ # # => "1,18 MB"
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
+ #
+ # [+:strip_insignificant_zeros+]
+ # Whether to remove insignificant zeros after the decimal separator.
+ # Defaults to true.
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#351
def number_to_human_size(number, options = T.unsafe(nil)); end
- # Formats a +number+ as a percentage string (e.g., 65%). You can
- # customize the format in the +options+ hash.
+ # Formats +number+ as a percentage string.
+ #
+ # number_to_percentage(100) # => "100.000%"
+ # number_to_percentage("99") # => "99.000%"
+ # number_to_percentage("99x") # => "99x%"
+ #
+ # number_to_percentage(12345.6789, delimiter: ".", separator: ",", precision: 2)
+ # # => "12.345,68%"
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :precision - Sets the precision of the number
- # (defaults to 3). Keeps the number's precision if +nil+.
- # * :round_mode - Determine how rounding is performed
- # (defaults to :default. See BigDecimal::mode)
- # * :significant - If +true+, precision will be the number
- # of significant_digits. If +false+, the number of fractional
- # digits (defaults to +false+).
- # * :separator - Sets the separator between the
- # fractional and integer digits (defaults to ".").
- # * :delimiter - Sets the thousands delimiter (defaults
- # to "").
- # * :strip_insignificant_zeros - If +true+ removes
- # insignificant zeros after the decimal separator (defaults to
- # +false+).
- # * :format - Specifies the format of the percentage
- # string The number field is %n (defaults to "%n%").
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
#
- # ==== Examples
+ # number_to_percentage(1000, locale: :fr)
+ # # => "1000,000%"
+ #
+ # [+:precision+]
+ # The level of precision, or +nil+ to preserve +number+'s precision.
+ # Defaults to 2.
+ #
+ # number_to_percentage(12.3456789, precision: 4) # => "12.3457%"
+ # number_to_percentage(99.999, precision: 0) # => "100%"
+ # number_to_percentage(99.999, precision: nil) # => "99.999%"
+ #
+ # [+:round_mode+]
+ # Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+ # +:default+.
+ #
+ # number_to_percentage(12.3456789, precision: 4, round_mode: :down)
+ # # => "12.3456%"
#
- # number_to_percentage(100) # => "100.000%"
- # number_to_percentage('98') # => "98.000%"
- # number_to_percentage(100, precision: 0) # => "100%"
- # number_to_percentage(1000, delimiter: '.', separator: ',') # => "1.000,000%"
- # number_to_percentage(302.24398923423, precision: 5) # => "302.24399%"
- # number_to_percentage(1000, locale: :fr) # => "1000,000%"
- # number_to_percentage(1000, precision: nil) # => "1000%"
- # number_to_percentage('98a') # => "98a%"
- # number_to_percentage(100, format: '%n %') # => "100.000 %"
- # number_to_percentage(302.24398923423, precision: 5, round_mode: :down) # => "302.24398%"
- #
- # source://activesupport//lib/active_support/number_helper.rb#154
+ # [+:significant+]
+ # Whether +:precision+ should be applied to significant digits instead of
+ # fractional digits. Defaults to false.
+ #
+ # number_to_percentage(12345.6789) # => "12345.679%"
+ # number_to_percentage(12345.6789, significant: true) # => "12300%"
+ # number_to_percentage(12345.6789, precision: 2) # => "12345.68%"
+ # number_to_percentage(12345.6789, precision: 2, significant: true) # => "12000%"
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
+ #
+ # [+:strip_insignificant_zeros+]
+ # Whether to remove insignificant zeros after the decimal separator.
+ # Defaults to false.
+ #
+ # [+:format+]
+ # The format of the output. %n represents the number. Defaults to
+ # "%n%".
+ #
+ # number_to_percentage(100, format: "%n %")
+ # # => "100.000 %"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#201
def number_to_percentage(number, options = T.unsafe(nil)); end
- # Formats a +number+ into a phone number (US by default e.g., (555)
- # 123-9876). You can customize the format in the +options+ hash.
+ # Formats +number+ into a phone number.
+ #
+ # number_to_phone(5551234) # => "555-1234"
+ # number_to_phone("5551234") # => "555-1234"
+ # number_to_phone(1235551234) # => "123-555-1234"
+ # number_to_phone("12x34") # => "12x34"
+ #
+ # number_to_phone(1235551234, delimiter: ".", country_code: 1, extension: 1343)
+ # # => "+1.123.555.1234 x 1343"
#
# ==== Options
#
- # * :area_code - Adds parentheses around the area code.
- # * :delimiter - Specifies the delimiter to use
- # (defaults to "-").
- # * :extension - Specifies an extension to add to the
- # end of the generated number.
- # * :country_code - Sets the country code for the phone
- # number.
- # * :pattern - Specifies how the number is divided into three
- # groups with the custom regexp to override the default format.
- # ==== Examples
+ # [+:area_code+]
+ # Whether to use parentheses for the area code. Defaults to false.
#
- # number_to_phone(5551234) # => "555-1234"
- # number_to_phone('5551234') # => "555-1234"
- # number_to_phone(1235551234) # => "123-555-1234"
- # number_to_phone(1235551234, area_code: true) # => "(123) 555-1234"
- # number_to_phone(1235551234, delimiter: ' ') # => "123 555 1234"
- # number_to_phone(1235551234, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
- # number_to_phone(1235551234, country_code: 1) # => "+1-123-555-1234"
- # number_to_phone('123a456') # => "123a456"
+ # number_to_phone(1235551234, area_code: true)
+ # # => "(123) 555-1234"
#
- # number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')
- # # => "+1.123.555.1234 x 1343"
+ # [+:delimiter+]
+ # The digit group delimiter to use. Defaults to "-".
#
- # number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
- # # => "(755) 6123-4567"
- # number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
- # # => "133-1234-5678"
+ # number_to_phone(1235551234, delimiter: " ")
+ # # => "123 555 1234"
#
- # source://activesupport//lib/active_support/number_helper.rb#53
+ # [+:country_code+]
+ # A country code to prepend.
+ #
+ # number_to_phone(1235551234, country_code: 1)
+ # # => "+1-123-555-1234"
+ #
+ # [+:extension+]
+ # An extension to append.
+ #
+ # number_to_phone(1235551234, extension: 555)
+ # # => "123-555-1234 x 555"
+ #
+ # [+:pattern+]
+ # A regexp that specifies how the digits should be grouped. The first
+ # three captures from the regexp are treated as digit groups.
+ #
+ # number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
+ # # => "133-1234-5678"
+ # number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
+ # # => "(755) 6123-4567"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#66
def number_to_phone(number, options = T.unsafe(nil)); end
- # Formats a +number+ with the specified level of
- # :precision (e.g., 112.32 has a precision of 2 if
- # +:significant+ is +false+, and 5 if +:significant+ is +true+).
- # You can customize the format in the +options+ hash.
+ # Formats +number+ to a specific level of precision.
+ #
+ # number_to_rounded(12345.6789) # => "12345.679"
+ # number_to_rounded(12345.6789, precision: 2) # => "12345.68"
+ # number_to_rounded(12345.6789, precision: 0) # => "12345"
+ # number_to_rounded(12345, precision: 5) # => "12345.00000"
#
# ==== Options
#
- # * :locale - Sets the locale to be used for formatting
- # (defaults to current locale).
- # * :precision - Sets the precision of the number
- # (defaults to 3). Keeps the number's precision if +nil+.
- # * :round_mode - Determine how rounding is performed
- # (defaults to :default. See BigDecimal::mode)
- # * :significant - If +true+, precision will be the number
- # of significant_digits. If +false+, the number of fractional
- # digits (defaults to +false+).
- # * :separator - Sets the separator between the
- # fractional and integer digits (defaults to ".").
- # * :delimiter - Sets the thousands delimiter (defaults
- # to "").
- # * :strip_insignificant_zeros - If +true+ removes
- # insignificant zeros after the decimal separator (defaults to
- # +false+).
+ # [+:locale+]
+ # The locale to use for formatting. Defaults to the current locale.
#
- # ==== Examples
+ # number_to_rounded(111.234, locale: :fr)
+ # # => "111,234"
+ #
+ # [+:precision+]
+ # The level of precision, or +nil+ to preserve +number+'s precision.
+ # Defaults to 3.
+ #
+ # number_to_rounded(12345.6789, precision: nil)
+ # # => "12345.6789"
+ #
+ # [+:round_mode+]
+ # Specifies how rounding is performed. See +BigDecimal.mode+. Defaults to
+ # +:default+.
+ #
+ # number_to_rounded(12.34, precision: 0, round_mode: :up)
+ # # => "13"
#
- # number_to_rounded(111.2345) # => "111.235"
- # number_to_rounded(111.2345, precision: 2) # => "111.23"
- # number_to_rounded(13, precision: 5) # => "13.00000"
- # number_to_rounded(389.32314, precision: 0) # => "389"
- # number_to_rounded(111.2345, significant: true) # => "111"
- # number_to_rounded(111.2345, precision: 1, significant: true) # => "100"
- # number_to_rounded(13, precision: 5, significant: true) # => "13.000"
- # number_to_rounded(13, precision: nil) # => "13"
- # number_to_rounded(389.32314, precision: 0, round_mode: :up) # => "390"
- # number_to_rounded(111.234, locale: :fr) # => "111,234"
- #
- # number_to_rounded(13, precision: 5, significant: true, strip_insignificant_zeros: true)
- # # => "13"
- #
- # number_to_rounded(389.32314, precision: 4, significant: true) # => "389.3"
- # number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
- # # => "1.111,23"
- #
- # source://activesupport//lib/active_support/number_helper.rb#236
+ # [+:significant+]
+ # Whether +:precision+ should be applied to significant digits instead of
+ # fractional digits. Defaults to false.
+ #
+ # number_to_rounded(12345.6789) # => "12345.679"
+ # number_to_rounded(12345.6789, significant: true) # => "12300"
+ # number_to_rounded(12345.6789, precision: 2) # => "12345.68"
+ # number_to_rounded(12345.6789, precision: 2, significant: true) # => "12000"
+ #
+ # [+:separator+]
+ # The decimal separator. Defaults to ".".
+ #
+ # [+:delimiter+]
+ # The thousands delimiter. Defaults to ",".
+ #
+ # [+:strip_insignificant_zeros+]
+ # Whether to remove insignificant zeros after the decimal separator.
+ # Defaults to false.
+ #
+ # number_to_rounded(12.34, strip_insignificant_zeros: false) # => "12.340"
+ # number_to_rounded(12.34, strip_insignificant_zeros: true) # => "12.34"
+ # number_to_rounded(12.3456, strip_insignificant_zeros: true) # => "12.346"
+ #
+ # source://activesupport//lib/active_support/number_helper.rb#298
def number_to_rounded(number, options = T.unsafe(nil)); end
end
@@ -10834,43 +10908,43 @@ class ActiveSupport::TestCase < ::Minitest::Test
# source://activesupport//lib/active_support/callbacks.rb#963
def _teardown_callbacks; end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#735
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#736
def assert_no_match(matcher, obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#664
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#665
def assert_not_empty(obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#675
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#676
def assert_not_equal(exp, act, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#687
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#688
def assert_not_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#699
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#700
def assert_not_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#706
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#707
def assert_not_includes(collection, obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#717
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#718
def assert_not_instance_of(cls, obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#727
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#728
def assert_not_kind_of(cls, obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#745
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#746
def assert_not_nil(obj, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#780
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#781
def assert_not_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#803
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#804
def assert_not_predicate(o1, op, msg = T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#811
- def assert_not_respond_to(obj, meth, msg = T.unsafe(nil)); end
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#813
+ def assert_not_respond_to(obj, meth, msg = T.unsafe(nil), include_all: T.unsafe(nil)); end
- # source://minitest/5.20.0/lib/minitest/assertions.rb#820
+ # source://minitest/5.21.1/lib/minitest/assertions.rb#822
def assert_not_same(exp, act, msg = T.unsafe(nil)); end
# source://activesupport//lib/active_support/testing/file_fixtures.rb#20
@@ -10882,7 +10956,7 @@ class ActiveSupport::TestCase < ::Minitest::Test
# source://activesupport//lib/active_support/test_case.rb#298
def inspect; end
- # source://minitest/5.20.0/lib/minitest.rb#307
+ # source://minitest/5.21.1/lib/minitest.rb#311
def method_name; end
class << self
@@ -11116,7 +11190,7 @@ module ActiveSupport::Testing::Assertions
# post :create, params: { status: { ok: true } }
# end
#
- # Provide the optional keyword argument :from to specify the expected
+ # Provide the optional keyword argument +:from+ to specify the expected
# initial value.
#
# assert_no_changes -> { Status.all_good? }, from: true do
@@ -11891,7 +11965,7 @@ module ActiveSupport::Testing::TimeHelpers
# end
# Time.current # => Sun, 09 Jul 2017 15:34:50 EST -05:00
#
- # source://activesupport//lib/active_support/testing/time_helpers.rb#252
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#256
def freeze_time(with_usec: T.unsafe(nil), &block); end
# Changes current time to the time in the future or in the past by a given time difference by
@@ -11945,7 +12019,7 @@ module ActiveSupport::Testing::TimeHelpers
#
# Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
#
- # source://activesupport//lib/active_support/testing/time_helpers.rb#226
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#230
def travel_back; end
# Changes current time to the given time by stubbing +Time.now+, +Time.new+,
@@ -12008,24 +12082,24 @@ module ActiveSupport::Testing::TimeHelpers
#
# Time.current # => Wed, 24 Nov 2004 01:04:44 EST -05:00
#
- # source://activesupport//lib/active_support/testing/time_helpers.rb#226
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#230
def unfreeze_time; end
private
# Returns the value of attribute in_block.
#
- # source://activesupport//lib/active_support/testing/time_helpers.rb#261
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#265
def in_block; end
# Sets the attribute in_block
#
# @param value the value to set the attribute in_block to.
#
- # source://activesupport//lib/active_support/testing/time_helpers.rb#261
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#265
def in_block=(_arg0); end
- # source://activesupport//lib/active_support/testing/time_helpers.rb#257
+ # source://activesupport//lib/active_support/testing/time_helpers.rb#261
def simple_stubs; end
end
@@ -15504,7 +15578,7 @@ class IO::Buffer
def get_string(*_arg0); end
def get_value(_arg0, _arg1); end
def get_values(_arg0, _arg1); end
- def hexdump; end
+ def hexdump(*_arg0); end
def inspect; end
def internal?; end
def locked; end
@@ -15514,6 +15588,7 @@ class IO::Buffer
def null?; end
def or!(_arg0); end
def pread(*_arg0); end
+ def private?; end
def pwrite(*_arg0); end
def read(*_arg0); end
def readonly?; end
@@ -15541,6 +15616,7 @@ class IO::Buffer
def for(_arg0); end
def map(*_arg0); end
def size_of(_arg0); end
+ def string(_arg0); end
end
end
@@ -15683,10 +15759,6 @@ module Kernel
end
end
-class LoadError < ::ScriptError
- include ::DidYouMean::Correctable
-end
-
# == Attribute Accessors per Thread
#
# Extends the module object with class/module and instance accessors for
diff --git a/sorbet/rbi/gems/bigdecimal@3.1.5.rbi b/sorbet/rbi/gems/bigdecimal@3.1.6.rbi
similarity index 100%
rename from sorbet/rbi/gems/bigdecimal@3.1.5.rbi
rename to sorbet/rbi/gems/bigdecimal@3.1.6.rbi
diff --git a/sorbet/rbi/gems/concurrent-ruby@1.2.2.rbi b/sorbet/rbi/gems/concurrent-ruby@1.2.3.rbi
similarity index 98%
rename from sorbet/rbi/gems/concurrent-ruby@1.2.2.rbi
rename to sorbet/rbi/gems/concurrent-ruby@1.2.3.rbi
index 6c849d1..e51423a 100644
--- a/sorbet/rbi/gems/concurrent-ruby@1.2.2.rbi
+++ b/sorbet/rbi/gems/concurrent-ruby@1.2.3.rbi
@@ -4131,7 +4131,7 @@ end
# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
# @see https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#setDaemon-boolean-
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#197
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#201
class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
# Create a new thread pool.
#
@@ -4143,7 +4143,7 @@ class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
# @return [FixedThreadPool] a new instance of FixedThreadPool
# @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#211
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb#215
def initialize(num_threads, opts = T.unsafe(nil)); end
end
@@ -4257,7 +4257,7 @@ Concurrent::GLOBAL_TIMER_SET = T.let(T.unsafe(nil), Concurrent::Delay)
#
# @see http://ruby-doc.org/core/Hash.html Ruby standard library `Hash`
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/hash.rb#47
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/hash.rb#49
class Concurrent::Hash < ::Hash; end
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/hash.rb#16
@@ -6476,7 +6476,7 @@ class Concurrent::PromiseExecutionError < ::StandardError; end
# {include:file:docs-source/promises-main.md}
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#12
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#13
module Concurrent::Promises
extend ::Concurrent::Promises::FactoryMethods::Configuration
extend ::Concurrent::Promises::FactoryMethods
@@ -6484,40 +6484,40 @@ end
# @abstract
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2037
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2047
class Concurrent::Promises::AbstractAnyPromise < ::Concurrent::Promises::BlockedPromise; end
# Common ancestor of {Event} and {Future} classes, many shared methods are defined here.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#512
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#513
class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object
include ::Concurrent::Promises::InternalStates
extend ::Concurrent::Synchronization::SafeInitialization
# @return [AbstractEventFuture] a new instance of AbstractEventFuture
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#521
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#522
def initialize(promise, default_executor); end
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#137
def __initialize_atomic_fields__; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#737
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#738
def add_callback_clear_delayed_node(node); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#732
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#733
def add_callback_notify_blocked(promise, index); end
# For inspection.
#
# @return [Array]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#701
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#702
def blocks; end
# For inspection.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#709
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#710
def callbacks; end
# Shortcut of {#chain_on} with default `:io` executor supplied.
@@ -6525,7 +6525,7 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @return [Future]
# @see #chain_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#595
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#596
def chain(*args, &task); end
# Chains the task to be executed asynchronously on executor after it is resolved.
@@ -6535,13 +6535,13 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [Future]
# @yieldreturn will become result of the returned Future.
# Its returned value becomes {Future#value} fulfilling it,
# raised exception becomes {Future#reason} rejecting it.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#613
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#614
def chain_on(executor, *args, &task); end
# Resolves the resolvable when receiver is resolved.
@@ -6549,7 +6549,7 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @param resolvable [Resolvable]
# @return [self]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#628
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#629
def chain_resolvable(resolvable); end
# Returns default executor.
@@ -6561,12 +6561,12 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @see FactoryMethods#any_fulfilled_future_on
# @see similar
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#589
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#590
def default_executor; end
# @return [String] Short string representation.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#618
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#619
def inspect; end
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#93
@@ -6577,7 +6577,7 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @return [self]
# @see #on_resolution_using
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#636
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#637
def on_resolution(*args, &callback); end
# Stores the callback to be executed synchronously on resolving thread after it is
@@ -6586,11 +6586,11 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @overload an_event.on_resolution!
# @overload a_future.on_resolution!
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#654
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#655
def on_resolution!(*args, &callback); end
# Stores the callback to be executed asynchronously on executor after it is resolved.
@@ -6600,33 +6600,33 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#672
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#673
def on_resolution_using(executor, *args, &callback); end
# Is it in pending state?
#
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#548
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#549
def pending?; end
# For inspection.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#715
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#716
def promise; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#687
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#688
def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
# Is it in resolved state?
#
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#554
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#555
def resolved?; end
# Returns its state.
@@ -6635,7 +6635,7 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @overload a_future.state
# @return [Symbol]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#542
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#543
def state; end
# Resolves the resolvable when receiver is resolved.
@@ -6643,12 +6643,12 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @param resolvable [Resolvable]
# @return [self]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#628
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#629
def tangle(resolvable); end
# @return [String] Short string representation.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#618
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#619
def to_s; end
# Propagates touch. Requests all the delayed futures, which it depends on, to be
@@ -6656,14 +6656,14 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
#
# @return [self]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#561
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#562
def touch; end
# For inspection.
#
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#721
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#722
def touched?; end
# Wait (block the Thread) until receiver is {#resolved?}.
@@ -6675,12 +6675,12 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @return [self, true, false] self implies timeout was not used, true implies timeout was used
# and it was resolved, false implies it was not resolved within timeout.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#577
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#578
def wait(timeout = T.unsafe(nil)); end
# For inspection.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#727
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#728
def waiting_threads; end
# Crates new object with same class with the executor set as its new default executor.
@@ -6692,30 +6692,30 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @see Event#with_default_executor
# @see Future#with_default_executor
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#682
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#683
def with_default_executor(executor); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#742
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#743
def with_hidden_resolvable; end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#749
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#750
def add_callback(method, *args); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#802
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#812
def async_callback_on_resolution(state, executor, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#786
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#796
def call_callback(method, state, args); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#790
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#800
def call_callbacks(state); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#762
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#763
def callback_clear_delayed_node(state, node); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#808
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#818
def callback_notify_blocked(state, promise, index); end
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/synchronization/object.rb#105
@@ -6732,188 +6732,188 @@ class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization:
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#767
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#768
def wait_until_resolved(timeout); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#798
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#808
def with_async(executor, *args, &block); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1786
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1796
class Concurrent::Promises::AbstractFlatPromise < ::Concurrent::Promises::BlockedPromise
# @return [AbstractFlatPromise] a new instance of AbstractFlatPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1788
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1798
def initialize(delayed_because, blockers_count, event_or_future); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1798
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1808
def touch; end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1818
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1828
def add_delayed_of(future); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1810
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1820
def on_resolvable(resolved_future, index); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1814
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1824
def resolvable?(countdown, future, index); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1806
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1816
def touched?; end
end
# @abstract
# @private
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1539
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1549
class Concurrent::Promises::AbstractPromise < ::Concurrent::Synchronization::Object
include ::Concurrent::Promises::InternalStates
extend ::Concurrent::Synchronization::SafeInitialization
# @return [AbstractPromise] a new instance of AbstractPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1543
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1553
def initialize(future); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1554
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1564
def default_executor; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1571
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1581
def delayed_because; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1548
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1558
def event; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1548
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1558
def future; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1565
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1575
def inspect; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1558
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1568
def state; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1565
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1575
def to_s; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1562
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1572
def touch; end
private
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1582
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1592
def evaluate_to(*args, block); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1577
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1587
def resolve_with(new_state, raise_on_reassign = T.unsafe(nil)); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2074
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2084
class Concurrent::Promises::AnyFulfilledFuturePromise < ::Concurrent::Promises::AnyResolvedFuturePromise
private
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2078
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2088
def resolvable?(countdown, event_or_future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2040
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2050
class Concurrent::Promises::AnyResolvedEventPromise < ::Concurrent::Promises::AbstractAnyPromise
# @return [AnyResolvedEventPromise] a new instance of AnyResolvedEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2044
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2054
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2052
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2062
def on_resolvable(resolved_future, index); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2048
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2058
def resolvable?(countdown, future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2057
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2067
class Concurrent::Promises::AnyResolvedFuturePromise < ::Concurrent::Promises::AbstractAnyPromise
# @return [AnyResolvedFuturePromise] a new instance of AnyResolvedFuturePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2061
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2071
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2069
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2079
def on_resolvable(resolved_future, index); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2065
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2075
def resolvable?(countdown, future, index); end
end
# @abstract
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1609
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1619
class Concurrent::Promises::BlockedPromise < ::Concurrent::Promises::InnerPromise
# @return [BlockedPromise] a new instance of BlockedPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1651
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1661
def initialize(delayed, blockers_count, future); end
# for inspection only
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1673
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1683
def blocked_by; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1664
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1674
def delayed_because; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1657
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1667
def on_blocker_resolution(future, index); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1668
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1678
def touch; end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1681
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1691
def clear_and_propagate_touch(stack_or_element = T.unsafe(nil)); end
# @raise [NotImplementedError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1700
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1710
def on_resolvable(resolved_future, index); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1696
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1706
def process_on_blocker_resolution(future, index); end
# @return [true, false] if resolvable
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1692
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1702
def resolvable?(countdown, future, index); end
class << self
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1642
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1652
def add_delayed(delayed1, delayed2); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1635
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1645
def new_blocked_by(blockers, *args, &block); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1613
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1623
def new_blocked_by1(blocker, *args, &block); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1620
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1630
def new_blocked_by2(blocker1, blocker2, *args, &block); end
private
@@ -6925,37 +6925,37 @@ end
# @abstract
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1706
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1716
class Concurrent::Promises::BlockedTaskPromise < ::Concurrent::Promises::BlockedPromise
# @raise [ArgumentError]
# @return [BlockedTaskPromise] a new instance of BlockedTaskPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1707
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1717
def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1715
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1725
def executor; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1756
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1766
class Concurrent::Promises::ChainPromise < ::Concurrent::Promises::BlockedTaskPromise
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1759
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1769
def on_resolvable(resolved_future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2085
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2095
class Concurrent::Promises::DelayPromise < ::Concurrent::Promises::InnerPromise
# @return [DelayPromise] a new instance of DelayPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2087
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2097
def initialize(default_executor); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2098
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2108
def delayed_because; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2094
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2104
def touch; end
end
@@ -6963,7 +6963,7 @@ end
# pending or resolved. It should be always resolved. Use {Future} to communicate rejections and
# cancellation.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#816
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#826
class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
# Creates a new event or a future which will be resolved when receiver and other are.
# Returns an event if receiver and other are events, otherwise returns a future.
@@ -6973,7 +6973,7 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future, Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#829
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#839
def &(other); end
# Creates a new event which will be resolved when the first of receiver, `event_or_future`
@@ -6981,7 +6981,7 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#843
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#853
def any(event_or_future); end
# Creates new event dependent on receiver which will not evaluate until touched, see {#touch}.
@@ -6989,7 +6989,7 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#853
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#863
def delay; end
# Creates new event dependent on receiver scheduled to execute on/in intended_time.
@@ -7000,24 +7000,24 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
# `Time` means to run on `intended_time`.
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#865
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#875
def schedule(intended_time); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#595
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#596
def then(*args, &task); end
# Returns self, since this is event
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#883
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#893
def to_event; end
# Converts event to a future. The future is fulfilled when the event is resolved, the future may never fail.
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#875
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#885
def to_future; end
# Crates new object with same class with the executor set as its new default executor.
@@ -7025,7 +7025,7 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#889
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#899
def with_default_executor(executor); end
# Creates a new event or a future which will be resolved when receiver and other are.
@@ -7036,7 +7036,7 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future, Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#829
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#839
def zip(other); end
# Creates a new event which will be resolved when the first of receiver, `event_or_future`
@@ -7044,37 +7044,37 @@ class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#843
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#853
def |(event_or_future); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#900
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#910
def callback_on_resolution(state, args, callback); end
# @raise [Concurrent::MultipleAssignmentError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#895
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#905
def rejected_resolution(raise_on_reassign, state); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1962
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1972
class Concurrent::Promises::EventWrapperPromise < ::Concurrent::Promises::BlockedPromise
# @return [EventWrapperPromise] a new instance of EventWrapperPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1963
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1973
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1969
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1979
def on_resolvable(resolved_future, index); end
end
# Container of all {Future}, {Event} factory methods. They are never constructed directly with
# new.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#45
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#46
module Concurrent::Promises::FactoryMethods
include ::Concurrent::Promises::FactoryMethods::Configuration
extend ::Concurrent::ReInclude
@@ -7086,7 +7086,7 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #any_resolved_future_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#277
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#278
def any(*futures_and_or_events); end
# Shortcut of {#any_event_on} with default `:io` executor supplied.
@@ -7094,10 +7094,10 @@ module Concurrent::Promises::FactoryMethods
# @return [Event]
# @see #any_event_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#318
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#319
def any_event(*futures_and_or_events); end
- # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
+ # Creates a new event which becomes resolved after the first futures_and_or_events resolves.
# If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
# futures un-executed if they are not required any more.
#
@@ -7107,7 +7107,7 @@ module Concurrent::Promises::FactoryMethods
# @param futures_and_or_events [AbstractEventFuture]
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#328
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#329
def any_event_on(default_executor, *futures_and_or_events); end
# Shortcut of {#any_fulfilled_future_on} with default `:io` executor supplied.
@@ -7115,12 +7115,12 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #any_fulfilled_future_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#299
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#300
def any_fulfilled_future(*futures_and_or_events); end
- # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
- # Its result equals result of the first resolved future or if all futures_and_or_events reject,
- # it has reason of the last resolved future.
+ # Creates a new future which is resolved after the first futures_and_or_events is fulfilled.
+ # Its result equals the result of the first resolved future or if all futures_and_or_events reject,
+ # it has reason of the last rejected future.
# If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
# futures un-executed if they are not required any more.
# If event is supplied, which does not have value and can be only resolved, it's
@@ -7132,7 +7132,7 @@ module Concurrent::Promises::FactoryMethods
# @param futures_and_or_events [AbstractEventFuture]
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#312
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#313
def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
# Shortcut of {#any_resolved_future_on} with default `:io` executor supplied.
@@ -7140,11 +7140,11 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #any_resolved_future_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#277
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#278
def any_resolved_future(*futures_and_or_events); end
- # Creates new future which is resolved after first futures_and_or_events is resolved.
- # Its result equals result of the first resolved future.
+ # Creates a new future which is resolved after the first futures_and_or_events is resolved.
+ # Its result equals the result of the first resolved future.
# If resolved it does not propagate {Concurrent::AbstractEventFuture#touch}, leaving delayed
# futures un-executed if they are not required any more.
# If event is supplied, which does not have value and can be only resolved, it's
@@ -7156,7 +7156,7 @@ module Concurrent::Promises::FactoryMethods
# @param futures_and_or_events [AbstractEventFuture]
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#293
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#294
def any_resolved_future_on(default_executor, *futures_and_or_events); end
# Shortcut of {#delay_on} with default `:io` executor supplied.
@@ -7164,10 +7164,10 @@ module Concurrent::Promises::FactoryMethods
# @return [Future, Event]
# @see #delay_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#189
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#190
def delay(*args, &task); end
- # Creates new event or future which is resolved only after it is touched,
+ # Creates a new event or future which is resolved only after it is touched,
# see {Concurrent::AbstractEventFuture#touch}.
#
# @overload delay_on
@@ -7176,10 +7176,10 @@ module Concurrent::Promises::FactoryMethods
# global executor. Default executor propagates to chained futures unless overridden with
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#206
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#207
def delay_on(default_executor, *args, &task); end
- # Creates resolved future with will be fulfilled with the given value.
+ # Creates a resolved future which will be fulfilled with the given value.
#
# @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. Default executor propagates to chained futures unless overridden with
@@ -7187,7 +7187,7 @@ module Concurrent::Promises::FactoryMethods
# @param value [Object]
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#126
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#127
def fulfilled_future(value, default_executor = T.unsafe(nil)); end
# Shortcut of {#future_on} with default `:io` executor supplied.
@@ -7195,24 +7195,24 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #future_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#93
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#94
def future(*args, &task); end
- # Constructs new Future which will be resolved after block is evaluated on default executor.
+ # Constructs a new Future which will be resolved after block is evaluated on default executor.
# Evaluation begins immediately.
#
# @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. Default executor propagates to chained futures unless overridden with
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [Future]
# @yield [*args] to the task.
# @yieldreturn will become result of the returned Future.
# Its returned value becomes {Future#value} fulfilling it,
# raised exception becomes {Future#reason} rejecting it.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#105
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#106
def future_on(default_executor, *args, &task); end
# General constructor. Behaves differently based on the argument's type. It's provided for convenience
@@ -7229,10 +7229,10 @@ module Concurrent::Promises::FactoryMethods
# @return [Event, Future]
# @see rejected_future, resolved_event, fulfilled_future
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#173
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#174
def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
- # Creates resolved future with will be rejected with the given reason.
+ # Creates a resolved future which will be rejected with the given reason.
#
# @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. Default executor propagates to chained futures unless overridden with
@@ -7240,7 +7240,7 @@ module Concurrent::Promises::FactoryMethods
# @param reason [Object]
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#135
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#136
def rejected_future(reason, default_executor = T.unsafe(nil)); end
# Shortcut of {#resolvable_event_on} with default `:io` executor supplied.
@@ -7248,18 +7248,18 @@ module Concurrent::Promises::FactoryMethods
# @return [ResolvableEvent]
# @see #resolvable_event_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#62
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#63
def resolvable_event; end
- # Created resolvable event, user is responsible for resolving the event once by
- # {Promises::ResolvableEvent#resolve}.
+ # Creates a resolvable event, user is responsible for resolving the event once
+ # by calling {Promises::ResolvableEvent#resolve}.
#
# @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. Default executor propagates to chained futures unless overridden with
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
# @return [ResolvableEvent]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#71
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#72
def resolvable_event_on(default_executor = T.unsafe(nil)); end
# Shortcut of {#resolvable_future_on} with default `:io` executor supplied.
@@ -7267,7 +7267,7 @@ module Concurrent::Promises::FactoryMethods
# @return [ResolvableFuture]
# @see #resolvable_future_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#77
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#78
def resolvable_future; end
# Creates resolvable future, user is responsible for resolving the future once by
@@ -7279,7 +7279,7 @@ module Concurrent::Promises::FactoryMethods
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
# @return [ResolvableFuture]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#87
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#88
def resolvable_future_on(default_executor = T.unsafe(nil)); end
# Creates resolved event.
@@ -7289,10 +7289,10 @@ module Concurrent::Promises::FactoryMethods
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#143
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#144
def resolved_event(default_executor = T.unsafe(nil)); end
- # Creates resolved future with will be either fulfilled with the given value or rejection with
+ # Creates a resolved future with will be either fulfilled with the given value or rejected with
# the given reason.
#
# @param fulfilled [true, false]
@@ -7303,7 +7303,7 @@ module Concurrent::Promises::FactoryMethods
# executor parameter or changed with {AbstractEventFuture#with_default_executor}.
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#117
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#118
def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
# Shortcut of {#schedule_on} with default `:io` executor supplied.
@@ -7311,10 +7311,10 @@ module Concurrent::Promises::FactoryMethods
# @return [Future, Event]
# @see #schedule_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#213
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#214
def schedule(intended_time, *args, &task); end
- # Creates new event or future which is resolved in intended_time.
+ # Creates a new event or future which is resolved in intended_time.
#
# @overload schedule_on
# @overload schedule_on
@@ -7324,7 +7324,7 @@ module Concurrent::Promises::FactoryMethods
# @param intended_time [Numeric, Time] `Numeric` means to run in `intended_time` seconds.
# `Time` means to run on `intended_time`.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#232
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#233
def schedule_on(default_executor, intended_time, *args, &task); end
# Shortcut of {#zip_futures_on} with default `:io` executor supplied.
@@ -7332,7 +7332,7 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #zip_futures_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#239
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#240
def zip(*futures_and_or_events); end
# Shortcut of {#zip_events_on} with default `:io` executor supplied.
@@ -7340,10 +7340,10 @@ module Concurrent::Promises::FactoryMethods
# @return [Event]
# @see #zip_events_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#261
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#262
def zip_events(*futures_and_or_events); end
- # Creates new event which is resolved after all futures_and_or_events are resolved.
+ # Creates a new event which is resolved after all futures_and_or_events are resolved.
# (Future is resolved when fulfilled or rejected.)
#
# @param default_executor [Executor, :io, :fast] Instance of an executor or a name of the
@@ -7352,7 +7352,7 @@ module Concurrent::Promises::FactoryMethods
# @param futures_and_or_events [AbstractEventFuture]
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#271
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#272
def zip_events_on(default_executor, *futures_and_or_events); end
# Shortcut of {#zip_futures_on} with default `:io` executor supplied.
@@ -7360,11 +7360,11 @@ module Concurrent::Promises::FactoryMethods
# @return [Future]
# @see #zip_futures_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#239
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#240
def zip_futures(*futures_and_or_events); end
- # Creates new future which is resolved after all futures_and_or_events are resolved.
- # Its value is array of zipped future values. Its reason is array of reasons for rejection.
+ # Creates a new future which is resolved after all futures_and_or_events are resolved.
+ # Its value is an array of zipped future values. Its reason is an array of reasons for rejection.
# If there is an error it rejects.
# If event is supplied, which does not have value and can be only resolved, it's
# represented as `:fulfilled` with value `nil`.
@@ -7375,51 +7375,51 @@ module Concurrent::Promises::FactoryMethods
# @param futures_and_or_events [AbstractEventFuture]
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#253
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#254
def zip_futures_on(default_executor, *futures_and_or_events); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#49
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#50
module Concurrent::Promises::FactoryMethods::Configuration
# @return [Executor, :io, :fast] the executor which is used when none is supplied
# to a factory method. The method can be overridden in the receivers of
# `include FactoryMethod`
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#53
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#54
def default_executor; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1830
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1840
class Concurrent::Promises::FlatEventPromise < ::Concurrent::Promises::AbstractFlatPromise
# @return [FlatEventPromise] a new instance of FlatEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1834
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1844
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1838
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1848
def process_on_blocker_resolution(future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1863
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1873
class Concurrent::Promises::FlatFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
# @raise [ArgumentError]
# @return [FlatFuturePromise] a new instance of FlatFuturePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1867
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1877
def initialize(delayed, blockers_count, levels, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1874
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1884
def process_on_blocker_resolution(future, index); end
end
# Represents a value which will become available in future. May reject with a reason instead,
# e.g. when the tasks raises an exception.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#907
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#917
class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# Creates a new event or a future which will be resolved when receiver and other are.
# Returns an event if receiver and other are events, otherwise returns a future.
@@ -7429,7 +7429,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1060
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1070
def &(other); end
# Creates a new event which will be resolved when the first of receiver, `event_or_future`
@@ -7438,10 +7438,10 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1075
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1085
def any(event_or_future); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1205
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1215
def apply(args, block); end
# Creates new future dependent on receiver which will not evaluate until touched, see {#touch}.
@@ -7449,7 +7449,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1085
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1095
def delay; end
# Allows rejected Future to be risen with `raise` method.
@@ -7461,7 +7461,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @raise [Concurrent::Error] when raising not rejected future
# @return [Exception]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1003
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1013
def exception(*args); end
# Creates new future which will have result of the future returned by receiver. If receiver
@@ -7470,7 +7470,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param level [Integer] how many levels of futures should flatten
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1110
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1120
def flat(level = T.unsafe(nil)); end
# Creates new event which will be resolved when the returned event by receiver is.
@@ -7478,7 +7478,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1120
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1130
def flat_event; end
# Creates new future which will have result of the future returned by receiver. If receiver
@@ -7487,19 +7487,19 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param level [Integer] how many levels of futures should flatten
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1110
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1120
def flat_future(level = T.unsafe(nil)); end
# Is it in fulfilled state?
#
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#911
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#921
def fulfilled?; end
# @return [String] Short string representation.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1225
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1235
def inspect; end
# Shortcut of {#on_fulfillment_using} with default `:io` executor supplied.
@@ -7507,19 +7507,19 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [self]
# @see #on_fulfillment_using
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1126
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1136
def on_fulfillment(*args, &callback); end
# Stores the callback to be executed synchronously on resolving thread after it is
# fulfilled. Does nothing on rejection.
#
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yield [value, *args] to the callback.
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1137
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1147
def on_fulfillment!(*args, &callback); end
# Stores the callback to be executed asynchronously on executor after it is
@@ -7528,12 +7528,12 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yield [value, *args] to the callback.
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1149
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1159
def on_fulfillment_using(executor, *args, &callback); end
# Shortcut of {#on_rejection_using} with default `:io` executor supplied.
@@ -7541,19 +7541,19 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [self]
# @see #on_rejection_using
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1155
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1165
def on_rejection(*args, &callback); end
# Stores the callback to be executed synchronously on resolving thread after it is
# rejected. Does nothing on fulfillment.
#
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yield [reason, *args] to the callback.
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1166
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1176
def on_rejection!(*args, &callback); end
# Stores the callback to be executed asynchronously on executor after it is
@@ -7562,12 +7562,12 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [self]
# @yield [reason, *args] to the callback.
# @yieldreturn is forgotten.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1178
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1188
def on_rejection_using(executor, *args, &callback); end
# Returns reason of future's rejection.
@@ -7582,14 +7582,14 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param timeout_value [Object] a value returned by the method when it times out
# @return [Object, timeout_value] the reason, or timeout_value on timeout, or nil on fulfillment.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#956
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#966
def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
# Is it in rejected state?
#
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#918
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#928
def rejected?; end
# Shortcut of {#rescue_on} with default `:io` executor supplied.
@@ -7597,7 +7597,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [Future]
# @see #rescue_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1042
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1052
def rescue(*args, &task); end
# Chains the task to be executed asynchronously on executor after it rejects. Does not run
@@ -7606,14 +7606,14 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [Future]
# @yield [reason, *args] to the task.
# @yieldreturn will become result of the returned Future.
# Its returned value becomes {Future#value} fulfilling it,
# raised exception becomes {Future#reason} rejecting it.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1054
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1064
def rescue_on(executor, *args, &task); end
# Returns triplet fulfilled?, value, reason.
@@ -7625,7 +7625,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [Array(Boolean, Object, Object), nil] triplet of fulfilled?, value, reason, or nil
# on timeout.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#971
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#981
def result(timeout = T.unsafe(nil)); end
# Allows to use futures as green threads. The receiver has to evaluate to a future which
@@ -7646,7 +7646,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# which is suppose to continue running.
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1200
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1210
def run(run_test = T.unsafe(nil)); end
# Creates new event dependent on receiver scheduled to execute on/in intended_time.
@@ -7657,7 +7657,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# `Time` means to run on `intended_time`.
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1092
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1102
def schedule(intended_time); end
# Shortcut of {#then_on} with default `:io` executor supplied.
@@ -7665,7 +7665,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [Future]
# @see #then_on
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1024
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1034
def then(*args, &task); end
# Chains the task to be executed asynchronously on executor after it fulfills. Does not run
@@ -7674,33 +7674,33 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @param executor [Executor, :io, :fast] Instance of an executor or a name of the
# global executor. The task is executed on it, default executor remains unchanged.
# @param args [Object] arguments which are passed to the task when it's executed.
- # (It might be prepended with other arguments, see the @yeild section).
+ # (It might be prepended with other arguments, see the @yield section).
# @return [Future]
# @yield [value, *args] to the task.
# @yieldreturn will become result of the returned Future.
# Its returned value becomes {Future#value} fulfilling it,
# raised exception becomes {Future#reason} rejecting it.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1036
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1046
def then_on(executor, *args, &task); end
# Converts future to event which is resolved when future is resolved by fulfillment or rejection.
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1212
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1222
def to_event; end
# Returns self, since this is a future
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1220
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1230
def to_future; end
# @return [String] Short string representation.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1225
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1235
def to_s; end
# Return value of the future.
@@ -7717,7 +7717,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# timeout_value on timeout,
# nil on rejection.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#940
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#950
def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
# Return value of the future.
@@ -7735,7 +7735,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# or nil on rejection,
# or timeout_value on timeout.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#987
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#997
def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
# Wait (block the Thread) until receiver is {#resolved?}.
@@ -7748,7 +7748,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
# @return [self, true, false] self implies timeout was not used, true implies timeout was used
# and it was resolved, false implies it was not resolved within timeout.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#977
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#987
def wait!(timeout = T.unsafe(nil)); end
# Crates new object with same class with the executor set as its new default executor.
@@ -7756,7 +7756,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1101
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1111
def with_default_executor(executor); end
# Creates a new event or a future which will be resolved when receiver and other are.
@@ -7767,7 +7767,7 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1060
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1070
def zip(other); end
# Creates a new event which will be resolved when the first of receiver, `event_or_future`
@@ -7776,253 +7776,253 @@ class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1075
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1085
def |(event_or_future); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1262
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1272
def async_callback_on_fulfillment(state, executor, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1268
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1278
def async_callback_on_rejection(state, executor, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1274
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1284
def callback_on_fulfillment(state, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1278
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1288
def callback_on_rejection(state, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1282
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1292
def callback_on_resolution(state, args, callback); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1241
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1251
def rejected_resolution(raise_on_reassign, state); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1237
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1247
def run_test(v); end
# @raise [self]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1256
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1266
def wait_until_resolved!(timeout = T.unsafe(nil)); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1974
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1984
class Concurrent::Promises::FutureWrapperPromise < ::Concurrent::Promises::BlockedPromise
# @return [FutureWrapperPromise] a new instance of FutureWrapperPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1975
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1985
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1981
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1991
def on_resolvable(resolved_future, index); end
end
# will be immediately resolved
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1773
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1783
class Concurrent::Promises::ImmediateEventPromise < ::Concurrent::Promises::InnerPromise
# @return [ImmediateEventPromise] a new instance of ImmediateEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1774
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1784
def initialize(default_executor); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1779
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1789
class Concurrent::Promises::ImmediateFuturePromise < ::Concurrent::Promises::InnerPromise
# @return [ImmediateFuturePromise] a new instance of ImmediateFuturePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1780
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1790
def initialize(default_executor, fulfilled, value, reason); end
end
# @abstract
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1605
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1615
class Concurrent::Promises::InnerPromise < ::Concurrent::Promises::AbstractPromise; end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#337
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#338
module Concurrent::Promises::InternalStates; end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#396
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#397
class Concurrent::Promises::InternalStates::Fulfilled < ::Concurrent::Promises::InternalStates::ResolvedWithResult
# @return [Fulfilled] a new instance of Fulfilled
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#398
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#399
def initialize(value); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#406
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#407
def apply(args, block); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#402
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#403
def fulfilled?; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#414
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#415
def reason; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#418
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#419
def to_sym; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#410
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#411
def value; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#424
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#425
class Concurrent::Promises::InternalStates::FulfilledArray < ::Concurrent::Promises::InternalStates::Fulfilled
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#425
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#426
def apply(args, block); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#487
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#488
Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Pending)
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#458
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#459
class Concurrent::Promises::InternalStates::PartiallyRejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
# @return [PartiallyRejected] a new instance of PartiallyRejected
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#459
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#460
def initialize(value, reason); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#481
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#482
def apply(args, block); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#465
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#466
def fulfilled?; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#477
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#478
def reason; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#469
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#470
def to_sym; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#473
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#474
def value; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#350
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#351
class Concurrent::Promises::InternalStates::Pending < ::Concurrent::Promises::InternalStates::State
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#351
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#352
def resolved?; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#355
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#356
def to_sym; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#489
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#490
Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Reserved)
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#491
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#492
Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Fulfilled)
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#431
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#432
class Concurrent::Promises::InternalStates::Rejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
# @return [Rejected] a new instance of Rejected
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#432
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#433
def initialize(reason); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#452
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#453
def apply(args, block); end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#436
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#437
def fulfilled?; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#444
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#445
def reason; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#448
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#449
def to_sym; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#440
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#441
def value; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#361
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#362
class Concurrent::Promises::InternalStates::Reserved < ::Concurrent::Promises::InternalStates::Pending; end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#365
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#366
class Concurrent::Promises::InternalStates::ResolvedWithResult < ::Concurrent::Promises::InternalStates::State
# @raise [NotImplementedError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#390
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#391
def apply; end
# @raise [NotImplementedError]
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#378
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#379
def fulfilled?; end
# @raise [NotImplementedError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#386
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#387
def reason; end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#366
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#367
def resolved?; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#374
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#375
def result; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#370
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#371
def to_sym; end
# @raise [NotImplementedError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#382
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#383
def value; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#339
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#340
class Concurrent::Promises::InternalStates::State
# @raise [NotImplementedError]
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#340
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#341
def resolved?; end
# @raise [NotImplementedError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#344
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#345
def to_sym; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1738
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1748
class Concurrent::Promises::RescuePromise < ::Concurrent::Promises::BlockedTaskPromise
# @return [RescuePromise] a new instance of RescuePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1741
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1751
def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1745
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1755
def on_resolvable(resolved_future, index); end
end
# Marker module of Future, Event resolved manually.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1289
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1299
module Concurrent::Promises::Resolvable
include ::Concurrent::Promises::InternalStates
end
# A Event which can be resolved by user.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1294
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1304
class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
include ::Concurrent::Promises::Resolvable
@@ -8035,7 +8035,7 @@ class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
# @return [self, false] false is returned when raise_on_reassign is false and the receiver
# is already resolved.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1314
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1324
def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
# Behaves as {AbstractEventFuture#wait} but has one additional optional argument
@@ -8045,28 +8045,28 @@ class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
# @return [self, true, false]
# @see AbstractEventFuture#wait
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1332
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1342
def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Creates new event wrapping receiver, effectively hiding the resolve method.
#
# @return [Event]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1321
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1331
def with_hidden_resolvable; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1590
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1600
class Concurrent::Promises::ResolvableEventPromise < ::Concurrent::Promises::AbstractPromise
# @return [ResolvableEventPromise] a new instance of ResolvableEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1591
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1601
def initialize(default_executor); end
end
# A Future which can be resolved by user.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1344
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1354
class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
include ::Concurrent::Promises::Resolvable
@@ -8077,7 +8077,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @yield [*args] to the block.
# @yieldreturn [Object] value
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1385
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1395
def evaluate_to(*args, &block); end
# Evaluates the block and sets its result as future's value fulfilling, if the block raises
@@ -8088,7 +8088,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @yield [*args] to the block.
# @yieldreturn [Object] value
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1396
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1406
def evaluate_to!(*args, &block); end
# Makes the future fulfilled with `value`,
@@ -8102,7 +8102,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [self, false] false is returned when raise_on_reassign is false and the receiver
# is already resolved.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1365
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1375
def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
# Behaves as {Future#reason} but has one additional optional argument
@@ -8113,7 +8113,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [Exception, timeout_value, nil]
# @see Future#reason
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1493
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1503
def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Makes the future rejected with `reason`,
@@ -8127,7 +8127,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [self, false] false is returned when raise_on_reassign is false and the receiver
# is already resolved.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1375
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1385
def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
# Makes the future resolved with result of triplet `fulfilled?`, `value`, `reason`,
@@ -8143,7 +8143,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [self, false] false is returned when raise_on_reassign is false and the receiver
# is already resolved.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1355
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1365
def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
# Behaves as {Future#result} but has one additional optional argument
@@ -8154,7 +8154,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [::Array(Boolean, Object, Exception), nil]
# @see Future#result
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1514
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1524
def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Behaves as {Future#value} but has one additional optional argument
@@ -8165,7 +8165,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [Object, timeout_value, nil]
# @see Future#value
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1449
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1459
def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Behaves as {Future#value!} but has one additional optional argument
@@ -8177,7 +8177,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [Object, timeout_value, nil]
# @see Future#value!
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1471
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1481
def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Behaves as {AbstractEventFuture#wait} but has one additional optional argument
@@ -8188,7 +8188,7 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [self, true, false]
# @see AbstractEventFuture#wait
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1411
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1421
def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Behaves as {Future#wait!} but has one additional optional argument
@@ -8200,123 +8200,123 @@ class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
# @return [self, true, false]
# @see Future#wait!
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1428
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1438
def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
# Creates new future wrapping receiver, effectively hiding the resolve method and similar.
#
# @return [Future]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1532
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1542
def with_hidden_resolvable; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1596
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1606
class Concurrent::Promises::ResolvableFuturePromise < ::Concurrent::Promises::AbstractPromise
# @return [ResolvableFuturePromise] a new instance of ResolvableFuturePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1597
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1607
def initialize(default_executor); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1582
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1592
def evaluate_to(*args, block); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1899
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1909
class Concurrent::Promises::RunFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
# @return [RunFuturePromise] a new instance of RunFuturePromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1903
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1913
def initialize(delayed, blockers_count, default_executor, run_test); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1908
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1918
def process_on_blocker_resolution(future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2104
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2114
class Concurrent::Promises::ScheduledPromise < ::Concurrent::Promises::InnerPromise
# @return [ScheduledPromise] a new instance of ScheduledPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2115
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2125
def initialize(default_executor, intended_time); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2109
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2119
def inspect; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2105
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2115
def intended_time; end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1720
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1730
class Concurrent::Promises::ThenPromise < ::Concurrent::Promises::BlockedTaskPromise
# @return [ThenPromise] a new instance of ThenPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1723
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1733
def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1727
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1737
def on_resolvable(resolved_future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1930
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1940
class Concurrent::Promises::ZipEventEventPromise < ::Concurrent::Promises::BlockedPromise
# @return [ZipEventEventPromise] a new instance of ZipEventEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1931
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1941
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1937
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1947
def on_resolvable(resolved_future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2021
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2031
class Concurrent::Promises::ZipEventsPromise < ::Concurrent::Promises::BlockedPromise
# @return [ZipEventsPromise] a new instance of ZipEventsPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2025
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2035
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2031
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2041
def on_resolvable(resolved_future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1942
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1952
class Concurrent::Promises::ZipFutureEventPromise < ::Concurrent::Promises::BlockedPromise
# @return [ZipFutureEventPromise] a new instance of ZipFutureEventPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1943
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1953
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1957
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1967
def on_resolvable(resolved_future, index); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1950
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1960
def process_on_blocker_resolution(future, index); end
end
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1986
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1996
class Concurrent::Promises::ZipFuturesPromise < ::Concurrent::Promises::BlockedPromise
# @return [ZipFuturesPromise] a new instance of ZipFuturesPromise
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1990
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2000
def initialize(delayed, blockers_count, default_executor); end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2003
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2013
def on_resolvable(resolved_future, index); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#1997
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/promises.rb#2007
def process_on_blocker_resolution(future, index); end
end
@@ -8926,11 +8926,18 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#45
def initialize(opts = T.unsafe(nil)); end
+ # The number of threads that are actively executing tasks.
+ #
+ # @return [Integer] The number of threads that are actively executing tasks.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#65
+ def active_count; end
+
# Does the task queue have a maximum size?
#
# @return [Boolean] True if the task queue has a maximum size else false.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#65
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#72
def can_overflow?; end
# The number of tasks that have been completed by the pool since construction.
@@ -8958,7 +8965,7 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
#
# @return [Integer] The number of threads currently in the pool.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#70
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#77
def length; end
# The maximum number of threads that may be created in the pool.
@@ -8996,17 +9003,17 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
# this method explicitely in case your application post jobs in bursts (a
# lot of jobs and then nothing for long periods)
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#111
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#118
def prune_pool; end
# The number of tasks in the queue awaiting execution.
#
# @return [Integer] The number of tasks in the queue awaiting execution.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#75
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#82
def queue_length; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#96
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#103
def ready_worker(worker, last_message); end
# Number of tasks that may be enqueued before reaching `max_queue` and rejecting
@@ -9015,10 +9022,10 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
# @return [Integer] Number of tasks that may be enqueued before reaching `max_queue` and rejecting
# new tasks. A value of -1 indicates that the queue may grow without bound.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#80
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#87
def remaining_capacity; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#91
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#98
def remove_busy_worker(worker); end
# The number of tasks that have been scheduled for execution on the pool since construction.
@@ -9035,10 +9042,10 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#42
def synchronous; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#101
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#108
def worker_died(worker); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#106
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#113
def worker_task_completed; end
private
@@ -9047,61 +9054,61 @@ class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
#
# @return [nil, Worker] nil of max capacity is reached
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#234
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#241
def ns_add_busy_worker; end
# tries to assign task to a worker, tries to get one from @ready or to create new one
#
# @return [true, false] if task is assigned to a worker
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#194
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#201
def ns_assign_worker(*args, &task); end
# tries to enqueue task
#
# @return [true, false] if enqueued
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#212
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#219
def ns_enqueue(*args, &task); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#153
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#160
def ns_execute(*args, &task); end
# @raise [ArgumentError]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#118
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#125
def ns_initialize(opts); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#182
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#189
def ns_kill_execution; end
# @return [Boolean]
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#148
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#155
def ns_limited_queue?; end
# try oldest worker if it is idle for enough time, it's returned back at the start
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#273
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#280
def ns_prune_pool; end
# handle ready worker, giving it new job or assigning back to @ready
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#246
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#253
def ns_ready_worker(worker, last_message, success = T.unsafe(nil)); end
# removes a worker which is not in not tracked in @ready
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#264
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#271
def ns_remove_busy_worker(worker); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#289
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#296
def ns_reset_if_forked; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#167
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#174
def ns_shutdown_execution; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#224
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#231
def ns_worker_died(worker); end
end
@@ -9131,31 +9138,31 @@ Concurrent::RubyThreadPoolExecutor::DEFAULT_SYNCHRONOUS = T.let(T.unsafe(nil), F
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#24
Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#303
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#310
class Concurrent::RubyThreadPoolExecutor::Worker
include ::Logger::Severity
include ::Concurrent::Concern::Logging
# @return [Worker] a new instance of Worker
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#306
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#313
def initialize(pool, id); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#317
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#324
def <<(message); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#325
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#332
def kill; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#321
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#328
def stop; end
private
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#331
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#338
def create_worker(queue, pool, idletime); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#351
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb#358
def run_task(pool, task, args); end
end
@@ -11010,6 +11017,17 @@ end
# be tested separately then passed to the `TimerTask` for scheduling and
# running.
#
+# A `TimerTask` supports two different types of interval calculations.
+# A fixed delay will always wait the same amount of time between the
+# completion of one task and the start of the next. A fixed rate will
+# attempt to maintain a constant rate of execution regardless of the
+# duration of the task. For example, if a fixed rate task is scheduled
+# to run every 60 seconds but the task itself takes 10 seconds to
+# complete, the next task will be scheduled to run 50 seconds after
+# the start of the previous task. If the task takes 70 seconds to
+# complete, the next task will be start immediately after the previous
+# task completes. Tasks will not be executed concurrently.
+#
# In some cases it may be necessary for a `TimerTask` to affect its own
# execution cycle. To facilitate this, a reference to the TimerTask instance
# is passed as an argument to the provided block every time the task is
@@ -11047,6 +11065,11 @@ end
# task.execute
#
# #=> 'Boom!'
+# @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+# task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+# puts 'Boom!'
+# end
+# task.interval_type #=> :fixed_rate
# @example Last `#value` and `Dereferenceable` mixin
# task = Concurrent::TimerTask.new(
# dup_on_deref: true,
@@ -11059,7 +11082,7 @@ end
# task.value #=> 2013-11-07 18:06:55 -0500
# @example Controlling execution from within the block
# timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-# task.execution_interval.times{ print 'Boom! ' }
+# task.execution_interval.to_i.times{ print 'Boom! ' }
# print "\n"
# task.execution_interval += 1
# if task.execution_interval > 5
@@ -11068,7 +11091,7 @@ end
# end
# end
#
-# timer_task.execute # blocking call - this task will stop itself
+# timer_task.execute
# #=> Boom!
# #=> Boom! Boom!
# #=> Boom! Boom! Boom!
@@ -11116,7 +11139,7 @@ end
# @see http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
# @see http://docs.oracle.com/javase/7/docs/api/java/util/TimerTask.html
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#148
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#165
class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
include ::Concurrent::Concern::Dereferenceable
include ::Concurrent::Concern::Observable
@@ -11125,6 +11148,7 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
#
# @option opts
# @option opts
+ # @option opts
# @param opts [Hash] the options defining task execution.
# @raise ArgumentError when no block is given.
# @return [TimerTask] the new `TimerTask`
@@ -11135,7 +11159,7 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
# refer to the execution context of the block rather than the running
# `TimerTask`.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#180
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#209
def initialize(opts = T.unsafe(nil), &task); end
# Execute a previously created `TimerTask`.
@@ -11150,38 +11174,43 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
# task.running? #=> true
# @return [TimerTask] a reference to `self`
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#206
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#235
def execute; end
# @return [Fixnum] Number of seconds after the task completes before the
# task is performed again.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#230
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#259
def execution_interval; end
# @return [Fixnum] Number of seconds after the task completes before the
# task is performed again.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#237
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#266
def execution_interval=(value); end
+ # @return [Symbol] method to calculate the interval between executions
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#276
+ def interval_type; end
+
# Is the executor running?
#
# @return [Boolean] `true` when running, `false` when shutting down or shutdown
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#189
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#218
def running?; end
# @return [Fixnum] Number of seconds the task can run before it is
# considered to have failed.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#248
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#281
def timeout_interval; end
# @return [Fixnum] Number of seconds the task can run before it is
# considered to have failed.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#255
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#288
def timeout_interval=(value); end
private
@@ -11189,22 +11218,25 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/executor_service.rb#166
def <<(task); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#297
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#352
+ def calculate_next_interval(start_time); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#336
def execute_task(completion); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#263
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#296
def ns_initialize(opts, &task); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#285
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#324
def ns_kill_execution; end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#279
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#318
def ns_shutdown_execution; end
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/ruby_executor_service.rb#17
def post(*args, &task); end
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#291
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#330
def schedule_next_task(interval = T.unsafe(nil)); end
class << self
@@ -11215,6 +11247,7 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
# task.running? #=> true
# @option opts
# @option opts
+ # @option opts
# @param opts [Hash] the options defining task execution.
# @raise ArgumentError when no block is given.
# @return [TimerTask] the new `TimerTask`
@@ -11225,20 +11258,32 @@ class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
# refer to the execution context of the block rather than the running
# `TimerTask`.
#
- # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#223
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#252
def execute(opts = T.unsafe(nil), &task); end
end
end
+# Default `:interval_type`
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#181
+Concurrent::TimerTask::DEFAULT_INTERVAL_TYPE = T.let(T.unsafe(nil), Symbol)
+
# Default `:execution_interval` in seconds.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#153
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#170
Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
-# Default `:timeout_interval` in seconds.
+# Maintain the interval between the end of one execution and the start of the next execution.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#173
+Concurrent::TimerTask::FIXED_DELAY = T.let(T.unsafe(nil), Symbol)
+
+# Maintain the interval between the start of one execution and the start of the next.
+# If execution time exceeds the interval, the next execution will start immediately
+# after the previous execution finishes. Executions will not run concurrently.
#
-# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#156
-Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer)
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/timer_task.rb#178
+Concurrent::TimerTask::FIXED_RATE = T.let(T.unsafe(nil), Symbol)
# source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#153
class Concurrent::Transaction